lua-cli 2.5.7 → 3.0.0-alpha.1

package/dist/utils/deployment.d.ts

@@ -21,5 +21,6 @@ export declare function createDeploymentData(tools: ToolInfo[], distDir: string)
  * @param tools - Array of detected tools
  * @param luaDir - Legacy .lua directory for output
  * @param indexFile - The TypeScript source file for the index
+ * @param agentData - Optional resolved agent data from LuaAgent (for new approach)
  */
-export declare function createLegacyDeploymentData(tools: ToolInfo[], luaDir: string, indexFile: TypeScriptSourceFile): Promise<void>;
+export declare function createLegacyDeploymentData(tools: ToolInfo[], luaDir: string, indexFile: TypeScriptSourceFile, agentData?: any): Promise<void>;

package/dist/utils/deployment.js

@@ -52,10 +52,24 @@ function readPackageJson() {
  * @param tools - Array of detected tools
  * @param luaDir - Legacy .lua directory for output
  * @param indexFile - The TypeScript source file for the index
+ * @param agentData - Optional resolved agent data from LuaAgent (for new approach)
  */
-export async function createLegacyDeploymentData(tools, luaDir, indexFile) {
+export async function createLegacyDeploymentData(tools, luaDir, indexFile, agentData) {
     const config = readSkillConfig();
-    const skillsMetadata = extractSkillsMetadata(indexFile);
+    let skillsMetadata;
+    // Check if we have agent data (from LuaAgent approach)
+    if (agentData && agentData.skills && agentData.skills.length > 0) {
+        // Use skills from LuaAgent
+        // Map 'tools' to 'constructorTools' for compatibility with buildSkillsArray
+        skillsMetadata = agentData.skills.map((skill) => ({
+            ...skill,
+            constructorTools: skill.tools || []
+        }));
+    }
+    else {
+        // Fall back to legacy approach - extract from index file
+        skillsMetadata = extractSkillsMetadata(indexFile);
+    }
     // Map tools to their parent skills
     const skillToTools = mapToolsToSkills(indexFile);
     // Build skills array with their associated tools

package/dist/utils/init-agent.d.ts

@@ -28,10 +28,12 @@ export declare function selectBaseAgentType(agentTypes: AgentType[]): AgentType;
  * @param businessConfig - Business configuration
  * @param metadata - Agent metadata
  * @param features - Feature configuration
+ * @param existingOrgId - Optional existing organization ID to use
+ * @param newOrgName - Optional new organization name (if not using existing)
  * @returns Agent creation result with agent and org details
  * @throws Error if agent creation fails
  */
-export declare function createNewAgent(apiKey: string, agentType: AgentType, businessConfig: BusinessConfig, metadata: Record<string, any>, features: Record<string, boolean>): Promise<AgentCreationResult>;
+export declare function createNewAgent(apiKey: string, agentType: AgentType, businessConfig: BusinessConfig, metadata: Record<string, any>, features: Record<string, boolean>, existingOrgId?: string, newOrgName?: string): Promise<AgentCreationResult>;
 /**
  * Fetches detailed agent information for an existing agent.
  * Used when selecting an existing agent during init.

package/dist/utils/init-agent.js

@@ -50,10 +50,12 @@ export function selectBaseAgentType(agentTypes) {
  * @param businessConfig - Business configuration
  * @param metadata - Agent metadata
  * @param features - Feature configuration
+ * @param existingOrgId - Optional existing organization ID to use
+ * @param newOrgName - Optional new organization name (if not using existing)
  * @returns Agent creation result with agent and org details
  * @throws Error if agent creation fails
  */
-export async function createNewAgent(apiKey, agentType, businessConfig, metadata, features) {
+export async function createNewAgent(apiKey, agentType, businessConfig, metadata, features, existingOrgId, newOrgName) {
     writeProgress("🔄 Creating agent...");
     const agentData = {
         id: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
@@ -67,9 +69,9 @@ export async function createNewAgent(apiKey, agentType, businessConfig, metadata
         },
         features,
         channels: [],
-        org: {
-            registeredName: businessConfig.businessName
-        }
+        org: existingOrgId
+            ? { id: existingOrgId } // Use existing org
+            : { registeredName: newOrgName || businessConfig.businessName } // Create new org
     };
     const agentApi = new AgentApi(BASE_URLS.API, apiKey);
     const createAgentResult = await agentApi.createAgent(agentData);

package/dist/utils/init-prompts.d.ts

@@ -42,6 +42,7 @@ export declare function promptFeatureConfiguration(agentType: AgentType): Promis
  * Prompts for business and agent configuration.
  * Collects business name, agent name, type, personality, and traits.
  *
+ * @param skipBusinessName - If true, skips business name prompt (for existing orgs)
  * @returns Complete business configuration
  */
-export declare function promptBusinessConfiguration(): Promise<BusinessConfig>;
+export declare function promptBusinessConfiguration(skipBusinessName?: boolean): Promise<BusinessConfig>;

package/dist/utils/init-prompts.js

@@ -115,17 +115,22 @@ export async function promptFeatureConfiguration(agentType) {
  * Prompts for business and agent configuration.
  * Collects business name, agent name, type, personality, and traits.
  *
+ * @param skipBusinessName - If true, skips business name prompt (for existing orgs)
  * @returns Complete business configuration
  */
-export async function promptBusinessConfiguration() {
-    const { businessName } = await inquirer.prompt([
-        {
-            type: "input",
-            name: "businessName",
-            message: "Enter business name:",
-            default: DEFAULT_BUSINESS_NAME
-        }
-    ]);
+export async function promptBusinessConfiguration(skipBusinessName = false) {
+    let businessName = DEFAULT_BUSINESS_NAME;
+    if (!skipBusinessName) {
+        const result = await inquirer.prompt([
+            {
+                type: "input",
+                name: "businessName",
+                message: "Enter business name:",
+                default: DEFAULT_BUSINESS_NAME
+            }
+        ]);
+        businessName = result.businessName;
+    }
     const { agentName } = await inquirer.prompt([
         {
             type: "input",

package/dist/utils/job-management.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Job Management Utilities
+ * Handles job creation via API and YAML configuration management
+ */
+import { SkillConfig } from '../types/compile.types.js';
+/**
+ * Ensures all detected jobs exist in the YAML config with valid job IDs.
+ * If a job doesn't exist or has no ID, creates it via the API.
+ *
+ * @param jobsArray - Array of jobs detected from source code
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated jobs array with valid job IDs
+ */
+export declare function ensureJobsExistInYaml(jobsArray: any[], config: SkillConfig): Promise<any[]>;
+/**
+ * Syncs the server jobs with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates jobs from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export declare function syncServerJobsWithYaml(config: SkillConfig): Promise<string[]>;

package/dist/utils/job-management.js

@@ -0,0 +1,264 @@
+/**
+ * Job Management Utilities
+ * Handles job creation via API and YAML configuration management
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import JobApi from '../api/job.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { loadApiKey } from '../services/auth.js';
+import { COMPILE_FILES, SKILL_DEFAULTS, YAML_FORMAT, } from '../config/compile.constants.js';
+/**
+ * Ensures all detected jobs exist in the YAML config with valid job IDs.
+ * If a job doesn't exist or has no ID, creates it via the API.
+ *
+ * @param jobsArray - Array of jobs detected from source code
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Updated jobs array with valid job IDs
+ */
+export async function ensureJobsExistInYaml(jobsArray, config) {
+    const updatedJobsArray = [];
+    let yamlUpdated = false;
+    const existingJobs = config?.jobs || [];
+    const existingJobsMap = createJobsMap(existingJobs);
+    // Process each detected job
+    for (const job of jobsArray) {
+        const existingJob = existingJobsMap.get(job.name);
+        if (existingJob && existingJob.jobId && existingJob.jobId !== '') {
+            // Job exists with valid jobId - reuse it
+            updatedJobsArray.push({
+                ...job,
+                jobId: existingJob.jobId
+            });
+        }
+        else {
+            // Job doesn't exist or missing jobId - create via API
+            const createdJob = await createJobViaApi(job, config, existingJobs, existingJob);
+            updatedJobsArray.push(createdJob);
+            yamlUpdated = true;
+        }
+    }
+    // Update YAML file if any changes were made
+    if (yamlUpdated) {
+        await updateYamlWithJobs(config);
+    }
+    return updatedJobsArray;
+}
+/**
+ * Creates a map of existing jobs for quick lookup by name.
+ *
+ * @param existingJobs - Array of jobs from YAML config
+ * @returns Map of job names to job objects
+ */
+function createJobsMap(existingJobs) {
+    const map = new Map();
+    existingJobs.forEach((job) => {
+        map.set(job.name, job);
+    });
+    return map;
+}
+/**
+ * Creates a new job via the Lua API and updates the config.
+ *
+ * @param job - The job to create
+ * @param config - The skill configuration
+ * @param existingJobs - Array of existing jobs (mutated)
+ * @param existingJob - The existing job entry if one exists (may be without ID)
+ * @returns The job with its new ID
+ */
+async function createJobViaApi(job, config, existingJobs, existingJob) {
+    try {
+        // Validate prerequisites
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            throw new Error("No API key found. Run 'lua auth configure' first.");
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            throw new Error("No agent ID found in lua.skill.yaml. Run 'lua init' first.");
+        }
+        // Create job via API
+        const jobPayload = {
+            name: job.name,
+            description: job.description || `A Lua job for ${job.name}`,
+            context: job.context || '',
+            schedule: job.schedule || { type: 'cron', expression: '0 0 * * *' },
+            timeout: job.timeout,
+            retry: job.retry,
+            metadata: job.metadata
+        };
+        const jobApi = new JobApi(BASE_URLS.API, apiKey, agentId);
+        const result = await jobApi.createJob(jobPayload);
+        if (result.success && result.data && result.data.id) {
+            const newJobId = result.data.id;
+            // Update YAML config with new job ID
+            if (!existingJob) {
+                existingJobs.push({
+                    name: job.name || '',
+                    version: job.version || SKILL_DEFAULTS.VERSION,
+                    jobId: newJobId,
+                    schedule: job.schedule
+                });
+            }
+            else {
+                existingJob.jobId = newJobId;
+                existingJob.schedule = job.schedule;
+            }
+            // Add jobs to config if not already present
+            if (!config.jobs) {
+                config.jobs = existingJobs;
+            }
+            return {
+                ...job,
+                jobId: newJobId
+            };
+        }
+        else {
+            console.error(`❌ Failed to create job ${job.name}:`, result.error);
+            throw new Error(result.error?.message || 'Failed to create job - no ID returned from API');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to create job ${job.name}:`, error);
+        throw error;
+    }
+}
+/**
+ * Updates the lua.skill.yaml file with the current jobs array.
+ * Ensures no undefined values are written to the YAML file.
+ *
+ * @param config - Current skill configuration to merge with
+ */
+async function updateYamlWithJobs(config) {
+    const jobs = config?.jobs || [];
+    // Clean jobs array to ensure no undefined values
+    const cleanedJobs = jobs.map(job => ({
+        name: job.name || '',
+        version: job.version || SKILL_DEFAULTS.VERSION,
+        jobId: job.jobId || '',
+        schedule: job.schedule || { type: 'cron', expression: '0 0 * * *' }
+    }));
+    // Update config with cleaned jobs array
+    const updatedConfig = {
+        ...config,
+        jobs: cleanedJobs
+    };
+    // Write updated YAML with consistent formatting
+    const yamlPath = path.join(process.cwd(), COMPILE_FILES.LUA_SKILL_YAML);
+    const yamlContent = yaml.dump(updatedConfig, {
+        indent: YAML_FORMAT.INDENT,
+        lineWidth: YAML_FORMAT.LINE_WIDTH,
+        noRefs: YAML_FORMAT.NO_REFS,
+        replacer: (key, value) => {
+            // Replace undefined values with empty strings
+            return value === undefined ? '' : value;
+        }
+    });
+    fs.writeFileSync(yamlPath, yamlContent);
+}
+/**
+ * Syncs the server jobs with the YAML configuration.
+ * Performs a two-way sync:
+ * 1. Deletes/deactivates jobs from server that aren't in YAML
+ * 2. Updates YAML with active version numbers from server
+ *
+ * @param config - The skill configuration from lua.skill.yaml
+ * @returns Array of messages about sync operations
+ */
+export async function syncServerJobsWithYaml(config) {
+    const messages = [];
+    let yamlNeedsUpdate = false;
+    try {
+        // Validate prerequisites
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.warn("⚠️  No API key found. Skipping server job sync.");
+            return messages;
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            console.warn("⚠️  No agent ID found in lua.skill.yaml. Skipping server job sync.");
+            return messages;
+        }
+        // Get jobs from server
+        const jobApi = new JobApi(BASE_URLS.API, apiKey, agentId);
+        const serverJobsResponse = await jobApi.getJobs();
+        if (!serverJobsResponse.success || !serverJobsResponse.data?.jobs) {
+            console.warn("⚠️  Could not retrieve server jobs. Skipping server job sync.");
+            return messages;
+        }
+        const serverJobs = serverJobsResponse.data.jobs;
+        const yamlJobs = config?.jobs || [];
+        // Create maps for efficient lookup
+        const yamlJobsMap = new Map(yamlJobs
+            .filter((job) => job.jobId)
+            .map((job) => [job.jobId, job]));
+        const serverJobsMap = new Map(serverJobs.map(job => [job.id, job]));
+        // Part 1: Delete jobs from server that aren't in YAML
+        const jobsToDelete = serverJobs.filter(serverJob => !yamlJobsMap.has(serverJob.id));
+        for (const job of jobsToDelete) {
+            try {
+                const deleteResponse = await jobApi.deleteJob(job.id);
+                if (deleteResponse.success && deleteResponse.data) {
+                    if (deleteResponse.data.deleted) {
+                        const msg = `✅ Deleted job "${job.name}" from server`;
+                        messages.push(msg);
+                        console.log(msg);
+                    }
+                    else if (deleteResponse.data.deactivated) {
+                        const msg = `⚠️  Job "${job.name}" has versions and cannot be deleted. It has been deactivated instead.`;
+                        messages.push(msg);
+                        console.warn(msg);
+                    }
+                }
+                else {
+                    const msg = `❌ Failed to delete job "${job.name}": ${deleteResponse.error?.message || 'Unknown error'}`;
+                    messages.push(msg);
+                    console.error(msg);
+                }
+            }
+            catch (error) {
+                const msg = `❌ Error deleting job "${job.name}": ${error}`;
+                messages.push(msg);
+                console.error(msg);
+            }
+        }
+        // Part 2: Sync version numbers from server to YAML
+        const updatedYamlJobs = yamlJobs.map((yamlJob) => {
+            const serverJob = serverJobsMap.get(yamlJob.jobId);
+            if (serverJob && serverJob.versions && serverJob.versions.length > 0) {
+                // Find the active version on the server
+                const activeVersion = serverJob.versions.find((v) => v.isActive);
+                if (activeVersion && activeVersion.version !== yamlJob.version) {
+                    const msg = `📝 Updated "${yamlJob.name}" job version in YAML: ${yamlJob.version} → ${activeVersion.version}`;
+                    messages.push(msg);
+                    console.log(msg);
+                    yamlNeedsUpdate = true;
+                    return {
+                        ...yamlJob,
+                        version: activeVersion.version,
+                        schedule: activeVersion.schedule || yamlJob.schedule
+                    };
+                }
+            }
+            return yamlJob;
+        });
+        // Update YAML file if versions changed
+        if (yamlNeedsUpdate) {
+            const updatedConfig = {
+                ...config,
+                jobs: updatedYamlJobs
+            };
+            await updateYamlWithJobs(updatedConfig);
+            console.log("✅ YAML job versions synced with server");
+        }
+        if (jobsToDelete.length === 0 && !yamlNeedsUpdate) {
+            console.log("✅ Server jobs and YAML are fully in sync");
+        }
+    }
+    catch (error) {
+        console.error("❌ Error syncing server jobs:", error);
+    }
+    return messages;
+}

package/dist/utils/postprocessor-management.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PostProcessor Management Utilities
+ */
+import { SkillConfig } from '../types/compile.types.js';
+/**
+ * Ensures all detected postprocessors exist in the YAML config with valid IDs.
+ */
+export declare function ensurePostProcessorsExistInYaml(postprocessorsArray: any[], config: SkillConfig): Promise<any[]>;
+export declare function syncServerPostProcessorsWithYaml(config: SkillConfig): Promise<string[]>;

package/dist/utils/postprocessor-management.js

@@ -0,0 +1,118 @@
+/**
+ * PostProcessor Management Utilities
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import PostProcessorApi from '../api/postprocessor.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { loadApiKey } from '../services/auth.js';
+import { SKILL_DEFAULTS, YAML_FORMAT } from '../config/compile.constants.js';
+/**
+ * Ensures all detected postprocessors exist in the YAML config with valid IDs.
+ */
+export async function ensurePostProcessorsExistInYaml(postprocessorsArray, config) {
+    const updatedPostProcessorsArray = [];
+    let yamlUpdated = false;
+    const existingPostProcessors = config?.postprocessors || [];
+    const existingMap = new Map(existingPostProcessors.map((p) => [p.name, p]));
+    for (const postprocessor of postprocessorsArray) {
+        const existing = existingMap.get(postprocessor.name);
+        if (existing && existing.postprocessorId) {
+            updatedPostProcessorsArray.push({
+                ...postprocessor,
+                postprocessorId: existing.postprocessorId
+            });
+        }
+        else {
+            const created = await createPostProcessorViaApi(postprocessor, config, existingPostProcessors, existing);
+            updatedPostProcessorsArray.push(created);
+            yamlUpdated = true;
+        }
+    }
+    if (yamlUpdated) {
+        await updateYamlWithPostProcessors(config);
+    }
+    return updatedPostProcessorsArray;
+}
+async function createPostProcessorViaApi(postprocessor, config, existingPostProcessors, existingPostProcessor) {
+    try {
+        const apiKey = await loadApiKey();
+        if (!apiKey)
+            throw new Error("No API key found. Run 'lua auth configure' first.");
+        const agentId = config?.agent?.agentId;
+        if (!agentId)
+            throw new Error("No agent ID found in lua.skill.yaml. Run 'lua init' first.");
+        const payload = {
+            name: postprocessor.name,
+            description: postprocessor.description || `A Lua postprocessor for ${postprocessor.name}`,
+            context: postprocessor.context || ''
+        };
+        const api = new PostProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const result = await api.createPostProcessor(payload);
+        if (result.success && result.data && result.data.id) {
+            const newId = result.data.id;
+            if (!existingPostProcessor) {
+                existingPostProcessors.push({
+                    name: postprocessor.name || '',
+                    version: postprocessor.version || SKILL_DEFAULTS.VERSION,
+                    postprocessorId: newId
+                });
+            }
+            else {
+                existingPostProcessor.postprocessorId = newId;
+            }
+            if (!config.postprocessors) {
+                config.postprocessors = existingPostProcessors;
+            }
+            return {
+                ...postprocessor,
+                postprocessorId: newId
+            };
+        }
+        else {
+            throw new Error(result.error?.message || "Failed to create postprocessor");
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Could not create postprocessor ${postprocessor.name}:`, error);
+        return postprocessor;
+    }
+}
+async function updateYamlWithPostProcessors(config) {
+    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
+    const yamlContent = yaml.dump(config, { ...YAML_FORMAT, sortKeys: (a, b) => {
+            const order = ['agent', 'skills', 'webhooks', 'jobs', 'preprocessors', 'postprocessors', 'skill'];
+            const aIndex = order.indexOf(a);
+            const bIndex = order.indexOf(b);
+            if (aIndex !== -1 && bIndex !== -1)
+                return aIndex - bIndex;
+            if (aIndex !== -1)
+                return -1;
+            if (bIndex !== -1)
+                return 1;
+            return a.localeCompare(b);
+        } });
+    fs.writeFileSync(yamlPath, yamlContent);
+}
+export async function syncServerPostProcessorsWithYaml(config) {
+    const messages = [];
+    try {
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.warn("⚠️  No API key found. Skipping server postprocessor sync.");
+            return messages;
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            console.warn("⚠️  No agent ID found. Skipping server postprocessor sync.");
+            return messages;
+        }
+        // Server sync will be implemented when backend is ready
+        return messages;
+    }
+    catch (error) {
+        console.warn("⚠️  Error syncing postprocessors:", error);
+        return messages;
+    }
+}

package/dist/utils/preprocessor-management.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PreProcessor Management Utilities
+ */
+import { SkillConfig } from '../types/compile.types.js';
+/**
+ * Ensures all detected preprocessors exist in the YAML config with valid IDs.
+ */
+export declare function ensurePreProcessorsExistInYaml(preprocessorsArray: any[], config: SkillConfig): Promise<any[]>;
+export declare function syncServerPreProcessorsWithYaml(config: SkillConfig): Promise<string[]>;

package/dist/utils/preprocessor-management.js

@@ -0,0 +1,118 @@
+/**
+ * PreProcessor Management Utilities
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import PreProcessorApi from '../api/preprocessor.api.service.js';
+import { BASE_URLS } from '../config/constants.js';
+import { loadApiKey } from '../services/auth.js';
+import { SKILL_DEFAULTS, YAML_FORMAT } from '../config/compile.constants.js';
+/**
+ * Ensures all detected preprocessors exist in the YAML config with valid IDs.
+ */
+export async function ensurePreProcessorsExistInYaml(preprocessorsArray, config) {
+    const updatedPreProcessorsArray = [];
+    let yamlUpdated = false;
+    const existingPreProcessors = config?.preprocessors || [];
+    const existingMap = new Map(existingPreProcessors.map((p) => [p.name, p]));
+    for (const preprocessor of preprocessorsArray) {
+        const existing = existingMap.get(preprocessor.name);
+        if (existing && existing.preprocessorId) {
+            updatedPreProcessorsArray.push({
+                ...preprocessor,
+                preprocessorId: existing.preprocessorId
+            });
+        }
+        else {
+            const created = await createPreProcessorViaApi(preprocessor, config, existingPreProcessors, existing);
+            updatedPreProcessorsArray.push(created);
+            yamlUpdated = true;
+        }
+    }
+    if (yamlUpdated) {
+        await updateYamlWithPreProcessors(config);
+    }
+    return updatedPreProcessorsArray;
+}
+async function createPreProcessorViaApi(preprocessor, config, existingPreProcessors, existingPreProcessor) {
+    try {
+        const apiKey = await loadApiKey();
+        if (!apiKey)
+            throw new Error("No API key found. Run 'lua auth configure' first.");
+        const agentId = config?.agent?.agentId;
+        if (!agentId)
+            throw new Error("No agent ID found in lua.skill.yaml. Run 'lua init' first.");
+        const payload = {
+            name: preprocessor.name,
+            description: preprocessor.description || `A Lua preprocessor for ${preprocessor.name}`,
+            context: preprocessor.context || ''
+        };
+        const api = new PreProcessorApi(BASE_URLS.API, apiKey, agentId);
+        const result = await api.createPreProcessor(payload);
+        if (result.success && result.data && result.data.id) {
+            const newId = result.data.id;
+            if (!existingPreProcessor) {
+                existingPreProcessors.push({
+                    name: preprocessor.name || '',
+                    version: preprocessor.version || SKILL_DEFAULTS.VERSION,
+                    preprocessorId: newId
+                });
+            }
+            else {
+                existingPreProcessor.preprocessorId = newId;
+            }
+            if (!config.preprocessors) {
+                config.preprocessors = existingPreProcessors;
+            }
+            return {
+                ...preprocessor,
+                preprocessorId: newId
+            };
+        }
+        else {
+            throw new Error(result.error?.message || "Failed to create preprocessor");
+        }
+    }
+    catch (error) {
+        console.warn(`Warning: Could not create preprocessor ${preprocessor.name}:`, error);
+        return preprocessor;
+    }
+}
+async function updateYamlWithPreProcessors(config) {
+    const yamlPath = path.join(process.cwd(), 'lua.skill.yaml');
+    const yamlContent = yaml.dump(config, { ...YAML_FORMAT, sortKeys: (a, b) => {
+            const order = ['agent', 'skills', 'webhooks', 'jobs', 'preprocessors', 'postprocessors', 'skill'];
+            const aIndex = order.indexOf(a);
+            const bIndex = order.indexOf(b);
+            if (aIndex !== -1 && bIndex !== -1)
+                return aIndex - bIndex;
+            if (aIndex !== -1)
+                return -1;
+            if (bIndex !== -1)
+                return 1;
+            return a.localeCompare(b);
+        } });
+    fs.writeFileSync(yamlPath, yamlContent);
+}
+export async function syncServerPreProcessorsWithYaml(config) {
+    const messages = [];
+    try {
+        const apiKey = await loadApiKey();
+        if (!apiKey) {
+            console.warn("⚠️  No API key found. Skipping server preprocessor sync.");
+            return messages;
+        }
+        const agentId = config?.agent?.agentId;
+        if (!agentId) {
+            console.warn("⚠️  No agent ID found. Skipping server preprocessor sync.");
+            return messages;
+        }
+        // Server sync will be implemented when backend is ready
+        return messages;
+    }
+    catch (error) {
+        console.warn("⚠️  Error syncing preprocessors:", error);
+        return messages;
+    }
+}