lua-cli 2.5.5 → 2.5.7

package/dist/commands/deploy.js

@@ -7,6 +7,7 @@ import { readSkillConfig } from '../utils/files.js';
 import { withErrorHandling, writeProgress, writeSuccess, writeInfo } from '../utils/cli.js';
 import { sortVersionsByDate, promptVersionSelection, confirmDeployment, validateDeployConfig, validateVersionsAvailable, promptSkillSelection, getAvailableSkills, } from '../utils/deploy-helpers.js';
 import { fetchVersions, publishVersion } from '../utils/deploy-api.js';
+import { updateSkillVersionInYaml } from '../utils/push-helpers.js';
 /**
  * Main deploy command - deploys a skill version to production.
  *
@@ -82,6 +83,12 @@ export async function deployCommand() {
         // Step 7: Publish the selected version
         writeProgress("🔄 Publishing version...");
         const publishResponse = await publishVersion(apiKey, config.agent.agentId, selectedSkill.skillId, selectedVersion);
-        writeSuccess(`✅ Version ${publishResponse.activeVersionId} of "${selectedSkill.name}" deployed successfully`);
+        const deployedVersion = publishResponse.activeVersionId;
+        writeSuccess(`✅ Version ${deployedVersion} of "${selectedSkill.name}" deployed successfully`);
+        // Step 8: Update YAML with the deployed version
+        if (deployedVersion !== selectedSkill.version) {
+            writeInfo(`📝 Updating YAML with deployed version: ${deployedVersion}`);
+            updateSkillVersionInYaml(selectedSkill.name, deployedVersion);
+        }
     }, "deployment");
 }

package/dist/commands/init.js

@@ -2,11 +2,13 @@
  * Init Command
  * Orchestrates the initialization of a new Lua skill project
  */
+import inquirer from 'inquirer';
 import { loadApiKey, checkApiKey } from "../services/auth.js";
-import { withErrorHandling, writeProgress, writeSuccess, } from "../utils/cli.js";
+import { withErrorHandling, writeProgress, writeSuccess, writeInfo, writeError, } from "../utils/cli.js";
 import { promptAgentChoice, promptOrganizationSelection, promptAgentSelection, promptMetadataCollection, promptFeatureConfiguration, promptBusinessConfiguration, } from "../utils/init-prompts.js";
-import { fetchAgentTypes, selectBaseAgentType, createNewAgent, } from "../utils/init-agent.js";
+import { fetchAgentTypes, selectBaseAgentType, createNewAgent, fetchExistingAgentDetails, } from "../utils/init-agent.js";
 import { initializeProject, installDependencies, clearLinesIfNeeded, } from "../utils/init-helpers.js";
+import { readSkillYaml, updateYamlAgent } from "../utils/files.js";
 /**
  * Main init command - initializes a new Lua skill project.
  *
@@ -40,40 +42,114 @@ export async function initCommand() {
         }
         const userData = await checkApiKey(apiKey);
         writeProgress("✅ Authenticated");
-        // Step 2: Choose between existing or new agent
+        // Step 2: Check for existing YAML file
+        const existingYaml = readSkillYaml();
+        const yamlExists = existingYaml !== null;
+        if (yamlExists) {
+            const existingAgentId = existingYaml?.agent?.agentId;
+            if (existingAgentId) {
+                // Check if user has access to this agent
+                const hasAccess = checkUserHasAccessToAgent(userData, existingAgentId);
+                if (!hasAccess) {
+                    writeError("\n⚠️  You don't have access to the agent in this project");
+                    writeInfo(`   Agent ID: ${existingAgentId}\n`);
+                    const { action } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: 'What would you like to do?',
+                            choices: [
+                                { name: '📧 Contact the agent admin to request access', value: 'contact' },
+                                { name: '🔄 Switch to a different agent', value: 'switch' },
+                                { name: '❌ Cancel', value: 'cancel' }
+                            ]
+                        }
+                    ]);
+                    if (action === 'contact') {
+                        writeInfo("\n💡 Please contact the agent administrator to grant you access.");
+                        writeInfo(`   Agent ID: ${existingAgentId}\n`);
+                        process.exit(0);
+                    }
+                    if (action === 'cancel') {
+                        writeInfo("\n❌ Initialization cancelled.\n");
+                        process.exit(0);
+                    }
+                    // User chose to switch agent - update existing YAML only
+                    await handleAgentSwitch(userData, apiKey, existingYaml);
+                    return;
+                }
+                else {
+                    // User has access - ask if they want to switch anyway
+                    writeInfo("\n📋 Found existing project configuration");
+                    writeInfo(`   Current Agent ID: ${existingAgentId}\n`);
+                    const { wantSwitch } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'wantSwitch',
+                            message: 'Do you want to switch this project to a different agent?',
+                            default: false
+                        }
+                    ]);
+                    if (wantSwitch) {
+                        // User wants to switch agent - update existing YAML only
+                        await handleAgentSwitch(userData, apiKey, existingYaml);
+                        return;
+                    }
+                    else {
+                        writeInfo("\n✅ Keeping current agent configuration\n");
+                        process.exit(0);
+                    }
+                }
+            }
+        }
+        // Step 3: Choose between existing or new agent
         const agentChoice = await promptAgentChoice();
         let selectedAgent;
         let selectedOrg;
         let persona;
         let welcomeMessage;
+        let skipProjectInit = false;
         if (agentChoice === "existing") {
-            // Step 3a: Select existing agent
-            const result = await selectExistingAgent(userData);
+            // Step 4a: Select existing agent
+            const result = await selectExistingAgent(userData, apiKey);
             selectedAgent = result.agent;
             selectedOrg = result.org;
+            persona = result.persona;
+            welcomeMessage = result.welcomeMessage;
         }
         else {
-            // Step 3b: Create new agent
+            // Step 4b: Create new agent
             const result = await createNewAgentFlow(apiKey);
             selectedAgent = result.agent;
             selectedOrg = result.org;
             persona = result.persona;
             welcomeMessage = result.welcomeMessage;
         }
-        // Step 4: Initialize project
-        const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
-        // Step 5: Install dependencies
-        await installDependencies(currentDir);
-        writeSuccess("✅ Lua skill project initialized successfully!");
+        // Step 5: Initialize or update project
+        if (yamlExists) {
+            // Update existing YAML only
+            writeInfo("📝 Updating existing lua.skill.yaml with new agent...");
+            updateYamlAgent(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
+            writeSuccess("✅ lua.skill.yaml updated successfully!");
+        }
+        else {
+            // Full project initialization
+            const currentDir = initializeProject(selectedAgent.agentId, selectedOrg.id, persona, welcomeMessage);
+            // Step 6: Install dependencies
+            await installDependencies(currentDir);
+            writeSuccess("✅ Lua skill project initialized successfully!");
+        }
     }, "initialization");
 }
 /**
  * Handles the flow for selecting an existing agent.
+ * Fetches the agent details from the server to get persona and welcomeMessage.
  *
  * @param userData - User's data
- * @returns Selected agent and organization
+ * @param apiKey - User's API key
+ * @returns Selected agent, organization, and optional persona/welcome message
  */
-async function selectExistingAgent(userData) {
+async function selectExistingAgent(userData, apiKey) {
     // Extract organizations
     const orgs = userData.admin.orgs;
     if (!orgs || orgs.length === 0) {
@@ -83,7 +159,14 @@ async function selectExistingAgent(userData) {
     const selectedOrg = await promptOrganizationSelection(orgs);
     // Select agent from organization
     const selectedAgent = await promptAgentSelection(selectedOrg);
-    return { agent: selectedAgent, org: selectedOrg };
+    // Fetch agent details to get persona and welcomeMessage
+    const agentDetails = await fetchExistingAgentDetails(apiKey, selectedAgent.agentId);
+    return {
+        agent: selectedAgent,
+        org: selectedOrg,
+        persona: agentDetails.persona,
+        welcomeMessage: agentDetails.welcomeMessage
+    };
 }
 /**
  * Handles the flow for creating a new agent.
@@ -115,3 +198,103 @@ async function createNewAgentFlow(apiKey) {
     const result = await createNewAgent(apiKey, selectedAgentType, businessConfig, metadata, features);
     return result;
 }
+/**
+ * Check if user has access to a specific agent
+ */
+function checkUserHasAccessToAgent(userData, agentId) {
+    const orgs = userData.admin.orgs;
+    for (const org of orgs) {
+        const agent = org.agents.find((a) => a.agentId === agentId);
+        if (agent) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Handle switching to a different agent
+ */
+async function handleAgentSwitch(userData, apiKey, existingYaml) {
+    writeInfo("\n🔄 Let's switch to a different agent...\n");
+    // Prompt for agent choice
+    const agentChoice = await promptAgentChoice();
+    let selectedAgent;
+    let selectedOrg;
+    let persona;
+    let welcomeMessage;
+    if (agentChoice === "existing") {
+        // Select existing agent
+        const result = await selectExistingAgent(userData, apiKey);
+        selectedAgent = result.agent;
+        selectedOrg = result.org;
+        persona = result.persona;
+        welcomeMessage = result.welcomeMessage;
+    }
+    else {
+        // Create new agent
+        const result = await createNewAgentFlow(apiKey);
+        selectedAgent = result.agent;
+        selectedOrg = result.org;
+        persona = result.persona;
+        welcomeMessage = result.welcomeMessage;
+    }
+    // Ask about persona and welcome message
+    const finalPersona = await promptPersonaReplacement(existingYaml, persona);
+    const finalWelcomeMessage = await promptWelcomeMessageReplacement(existingYaml, welcomeMessage);
+    // Update existing YAML file with new agent
+    writeInfo("\n📝 Updating lua.skill.yaml with new agent...");
+    updateYamlAgent(selectedAgent.agentId, selectedOrg.id, finalPersona, finalWelcomeMessage);
+    writeSuccess("✅ lua.skill.yaml updated successfully!");
+    writeInfo("\n💡 Your project now uses the new agent. Run 'lua compile' to update your skills.\n");
+}
+/**
+ * Prompt user about replacing existing persona
+ */
+async function promptPersonaReplacement(existingYaml, newPersona) {
+    const existingPersona = existingYaml?.agent?.persona;
+    // If no existing persona, use new one
+    if (!existingPersona) {
+        return newPersona;
+    }
+    // If no new persona, keep existing
+    if (!newPersona) {
+        return existingPersona;
+    }
+    // Both exist - ask user
+    writeInfo("\n📝 Persona Configuration:");
+    writeInfo("   Existing persona found in project");
+    const { replacePersona } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'replacePersona',
+            message: 'Replace existing persona with the new agent\'s persona?',
+            default: false
+        }
+    ]);
+    return replacePersona ? newPersona : existingPersona;
+}
+/**
+ * Prompt user about replacing existing welcome message
+ */
+async function promptWelcomeMessageReplacement(existingYaml, newWelcomeMessage) {
+    const existingWelcomeMessage = existingYaml?.agent?.welcomeMessage;
+    // If no existing welcome message, use new one
+    if (!existingWelcomeMessage) {
+        return newWelcomeMessage;
+    }
+    // If no new welcome message, keep existing
+    if (!newWelcomeMessage) {
+        return existingWelcomeMessage;
+    }
+    // Both exist - ask user
+    writeInfo("   Existing welcome message found in project");
+    const { replaceWelcomeMessage } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'replaceWelcomeMessage',
+            message: 'Replace existing welcome message with the new agent\'s welcome message?',
+            default: false
+        }
+    ]);
+    return replaceWelcomeMessage ? newWelcomeMessage : existingWelcomeMessage;
+}

package/dist/commands/logs.js

@@ -160,7 +160,9 @@ function displayLogs(logs, pagination, title) {
         writeInfo("No logs found.");
         return;
     }
-    logs.forEach((log, index) => {
+    // Reverse logs so latest appears at the bottom (oldest first, newest last)
+    const reversedLogs = [...logs].reverse();
+    reversedLogs.forEach((log, index) => {
         const timestamp = new Date(log.timestamp).toLocaleString();
         const icon = getLogIcon(log.subType);
         const color = getLogColor(log.subType);
@@ -179,7 +181,7 @@ function displayLogs(logs, pagination, title) {
             ? log.message.substring(0, 200) + '...'
             : log.message;
         console.log(`   ${message}`);
-        if (index < logs.length - 1) {
+        if (index < reversedLogs.length - 1) {
             console.log(chalk.gray(`   ${'-'.repeat(78)}`));
         }
     });

package/dist/commands/push.js

@@ -85,7 +85,14 @@ export async function pushCommand() {
         writeProgress("🔄 Pushing version to server...");
         const result = await pushVersion(apiKey, agentId, skillId, skillDeployData);
         if (result.success && result.data) {
-            writeSuccess(`✅ Version ${result.data.version} of "${selectedSkill.name}" pushed successfully`);
+            const pushedVersion = result.data.version;
+            writeSuccess(`✅ Version ${pushedVersion} of "${selectedSkill.name}" pushed successfully`);
+            // Update YAML with the version returned from server (in case it's different)
+            if (pushedVersion !== selectedSkill.version) {
+                writeInfo(`📝 Updating YAML with server version: ${pushedVersion}`);
+                updateSkillVersionInYaml(selectedSkill.name, pushedVersion);
+                selectedSkill.version = pushedVersion;
+            }
             // Ask if user wants to deploy now
             const deployAnswer = await safePrompt([
                 {
@@ -96,7 +103,7 @@ export async function pushCommand() {
                 }
             ]);
             if (deployAnswer && deployAnswer.deployNow) {
-                await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, result.data.version);
+                await deployVersionAfterPush(apiKey, config.agent.agentId, selectedSkill, pushedVersion);
             }
         }
         else if (result.error) {
@@ -145,6 +152,9 @@ async function deployVersionAfterPush(apiKey, agentId, selectedSkill, pushedVers
         writeProgress("🔄 Publishing version...");
         const publishResponse = await publishVersion(apiKey, agentId, selectedSkill.skillId, pushedVersion);
         writeSuccess(`\n✅ Version ${pushedVersion} of "${selectedSkill.name}" deployed successfully to production\n`);
+        // Update YAML with deployed version (should already be updated from push, but ensure consistency)
+        writeInfo(`📝 Ensuring YAML is updated with deployed version: ${pushedVersion}`);
+        updateSkillVersionInYaml(selectedSkill.name, pushedVersion);
     }
     catch (error) {
         console.error('\n❌ Error deploying version:', error);

package/dist/common/basket.instance.js

@@ -12,15 +12,16 @@ export default class BasketInstance {
      * @returns Proxied instance that allows direct access to data and common properties
      */
     constructor(api, basket) {
-        this.data = basket.data;
-        this.common = basket.common;
+        // Ensure data and common are always objects, never null or undefined
+        this.data = basket.data && typeof basket.data === 'object' ? basket.data : {};
+        this.common = basket.common && typeof basket.common === 'object' ? basket.common : {};
         this.id = basket.id;
         this.userId = basket.userId;
         this.agentId = basket.agentId;
-        this.metadata = basket.data.metadata;
-        this.totalAmount = basket.common.totalAmount;
-        this.itemCount = basket.common.itemCount;
-        this.status = basket.common.status;
+        this.metadata = basket.data?.metadata || {};
+        this.totalAmount = basket.common?.totalAmount || 0;
+        this.itemCount = basket.common?.itemCount || 0;
+        this.status = basket.common?.status || BasketStatus.ACTIVE;
         // Make basketAPI non-enumerable so it doesn't show up in console.log
         Object.defineProperty(this, 'basketAPI', {
             value: api,
@@ -35,12 +36,12 @@ export default class BasketInstance {
                 if (prop in target) {
                     return Reflect.get(target, prop, receiver);
                 }
-                // Check data object
-                if (typeof prop === 'string' && prop in target.data) {
+                // Check data object (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return target.data[prop];
                 }
-                // Check common object
-                if (typeof prop === 'string' && prop in target.common) {
+                // Check common object (with null check)
+                if (typeof prop === 'string' && target.common && typeof target.common === 'object' && prop in target.common) {
                     return target.common[prop];
                 }
                 return undefined;
@@ -53,6 +54,13 @@ export default class BasketInstance {
                 }
                 // Check if property exists in data or common, otherwise default to data
                 if (typeof prop === 'string') {
+                    // Initialize objects if they don't exist
+                    if (!target.data || typeof target.data !== 'object') {
+                        target.data = {};
+                    }
+                    if (!target.common || typeof target.common !== 'object') {
+                        target.common = {};
+                    }
                     if (prop in target.common) {
                         target.common[prop] = value;
                     }
@@ -64,14 +72,25 @@ export default class BasketInstance {
                 return false;
             },
             has(target, prop) {
-                // Check if property exists on instance, in data, or in common
-                return prop in target || (typeof prop === 'string' && (prop in target.data || prop in target.common));
+                // Check if property exists on instance, in data, or in common (with null checks)
+                if (prop in target) {
+                    return true;
+                }
+                if (typeof prop === 'string') {
+                    if (target.data && typeof target.data === 'object' && prop in target.data) {
+                        return true;
+                    }
+                    if (target.common && typeof target.common === 'object' && prop in target.common) {
+                        return true;
+                    }
+                }
+                return false;
             },
             ownKeys(target) {
-                // Return instance keys, data keys, and common keys
+                // Return instance keys, data keys, and common keys (with null checks)
                 const instanceKeys = Reflect.ownKeys(target);
-                const dataKeys = Object.keys(target.data);
-                const commonKeys = Object.keys(target.common);
+                const dataKeys = target.data && typeof target.data === 'object' ? Object.keys(target.data) : [];
+                const commonKeys = target.common && typeof target.common === 'object' ? Object.keys(target.common) : [];
                 return [...new Set([...instanceKeys, ...dataKeys, ...commonKeys])];
             },
             getOwnPropertyDescriptor(target, prop) {
@@ -80,8 +99,8 @@ export default class BasketInstance {
                 if (instanceDesc) {
                     return instanceDesc;
                 }
-                // Then check data properties
-                if (typeof prop === 'string' && prop in target.data) {
+                // Then check data properties (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return {
                         configurable: true,
                         enumerable: true,
@@ -89,8 +108,8 @@ export default class BasketInstance {
                         value: target.data[prop]
                     };
                 }
-                // Then check common properties
-                if (typeof prop === 'string' && prop in target.common) {
+                // Then check common properties (with null check)
+                if (typeof prop === 'string' && target.common && typeof target.common === 'object' && prop in target.common) {
                     return {
                         configurable: true,
                         enumerable: true,

package/dist/common/data.entry.instance.js

@@ -12,7 +12,8 @@ export default class DataEntryInstance {
      * @returns Proxied instance that allows direct access to data properties
      */
     constructor(api, entry, collectionName) {
-        this.data = entry.data;
+        // Ensure data is always an object, never null or undefined
+        this.data = entry.data && typeof entry.data === 'object' ? entry.data : {};
         this.id = entry.id;
         this.collectionName = collectionName;
         this.score = entry.score;
@@ -30,8 +31,8 @@ export default class DataEntryInstance {
                 if (prop in target) {
                     return Reflect.get(target, prop, receiver);
                 }
-                // Otherwise, try to get it from the data object
-                if (typeof prop === 'string' && prop in target.data) {
+                // Otherwise, try to get it from the data object (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return target.data[prop];
                 }
                 return undefined;
@@ -44,19 +45,29 @@ export default class DataEntryInstance {
                 }
                 // All other properties get set on the data object
                 if (typeof prop === 'string') {
+                    // Initialize data object if it doesn't exist
+                    if (!target.data || typeof target.data !== 'object') {
+                        target.data = {};
+                    }
                     target.data[prop] = value;
                     return true;
                 }
                 return false;
             },
             has(target, prop) {
-                // Check if property exists on instance or in data
-                return prop in target || (typeof prop === 'string' && prop in target.data);
+                // Check if property exists on instance or in data (with null check)
+                if (prop in target) {
+                    return true;
+                }
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object') {
+                    return prop in target.data;
+                }
+                return false;
             },
             ownKeys(target) {
-                // Return both instance keys and data keys
+                // Return both instance keys and data keys (with null check)
                 const instanceKeys = Reflect.ownKeys(target);
-                const dataKeys = Object.keys(target.data);
+                const dataKeys = target.data && typeof target.data === 'object' ? Object.keys(target.data) : [];
                 return [...new Set([...instanceKeys, ...dataKeys])];
             },
             getOwnPropertyDescriptor(target, prop) {
@@ -65,8 +76,8 @@ export default class DataEntryInstance {
                 if (instanceDesc) {
                     return instanceDesc;
                 }
-                // Then check if it's a data property
-                if (typeof prop === 'string' && prop in target.data) {
+                // Then check if it's a data property (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return {
                         configurable: true,
                         enumerable: true,

package/dist/common/order.instance.js

@@ -11,8 +11,9 @@ export default class OrderInstance {
      * @returns Proxied instance that allows direct access to data and common properties
      */
     constructor(api, order) {
-        this.data = order.data;
-        this.common = order.common;
+        // Ensure data and common are always objects, never null or undefined
+        this.data = order.data && typeof order.data === 'object' ? order.data : {};
+        this.common = order.common && typeof order.common === 'object' ? order.common : {};
         this.id = order.id;
         this.userId = order.userId;
         this.agentId = order.agentId;
@@ -31,12 +32,12 @@ export default class OrderInstance {
                 if (prop in target) {
                     return Reflect.get(target, prop, receiver);
                 }
-                // Check data object
-                if (typeof prop === 'string' && prop in target.data) {
+                // Check data object (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return target.data[prop];
                 }
-                // Check common object
-                if (typeof prop === 'string' && prop in target.common) {
+                // Check common object (with null check)
+                if (typeof prop === 'string' && target.common && typeof target.common === 'object' && prop in target.common) {
                     return target.common[prop];
                 }
                 return undefined;
@@ -49,6 +50,13 @@ export default class OrderInstance {
                 }
                 // Check if property exists in data or common, otherwise default to data
                 if (typeof prop === 'string') {
+                    // Initialize objects if they don't exist
+                    if (!target.data || typeof target.data !== 'object') {
+                        target.data = {};
+                    }
+                    if (!target.common || typeof target.common !== 'object') {
+                        target.common = {};
+                    }
                     if (prop in target.common) {
                         target.common[prop] = value;
                     }
@@ -60,14 +68,25 @@ export default class OrderInstance {
                 return false;
             },
             has(target, prop) {
-                // Check if property exists on instance, in data, or in common
-                return prop in target || (typeof prop === 'string' && (prop in target.data || prop in target.common));
+                // Check if property exists on instance, in data, or in common (with null checks)
+                if (prop in target) {
+                    return true;
+                }
+                if (typeof prop === 'string') {
+                    if (target.data && typeof target.data === 'object' && prop in target.data) {
+                        return true;
+                    }
+                    if (target.common && typeof target.common === 'object' && prop in target.common) {
+                        return true;
+                    }
+                }
+                return false;
             },
             ownKeys(target) {
-                // Return instance keys, data keys, and common keys
+                // Return instance keys, data keys, and common keys (with null checks)
                 const instanceKeys = Reflect.ownKeys(target);
-                const dataKeys = Object.keys(target.data);
-                const commonKeys = Object.keys(target.common);
+                const dataKeys = target.data && typeof target.data === 'object' ? Object.keys(target.data) : [];
+                const commonKeys = target.common && typeof target.common === 'object' ? Object.keys(target.common) : [];
                 return [...new Set([...instanceKeys, ...dataKeys, ...commonKeys])];
             },
             getOwnPropertyDescriptor(target, prop) {
@@ -76,8 +95,8 @@ export default class OrderInstance {
                 if (instanceDesc) {
                     return instanceDesc;
                 }
-                // Then check data properties
-                if (typeof prop === 'string' && prop in target.data) {
+                // Then check data properties (with null check)
+                if (typeof prop === 'string' && target.data && typeof target.data === 'object' && prop in target.data) {
                     return {
                         configurable: true,
                         enumerable: true,
@@ -85,8 +104,8 @@ export default class OrderInstance {
                         value: target.data[prop]
                     };
                 }
-                // Then check common properties
-                if (typeof prop === 'string' && prop in target.common) {
+                // Then check common properties (with null check)
+                if (typeof prop === 'string' && target.common && typeof target.common === 'object' && prop in target.common) {
                     return {
                         configurable: true,
                         enumerable: true,