@hailer/mcp 0.2.1 → 0.2.3

package/dist/app.js

@@ -11,8 +11,8 @@ const user_1 = require("./mcp/tools/user");
 const workflow_1 = require("./mcp/tools/workflow");
 const insight_1 = require("./mcp/tools/insight");
 const app_1 = require("./mcp/tools/app");
-const bot_config_1 = require("./bot-config");
-const bug_fixer_tools_1 = require("./mcp/tools/bug-fixer-tools");
+// Bot config and bug-fixer tools are dynamically imported only when MCP_CLIENT_ENABLED=true
+// This allows the npm package to work without these modules
 const core = new core_1.Core();
 logger.info('Registering tools...');
 logger.info('Nuclear tools status', { enabled: config_1.environment.ENABLE_NUCLEAR_TOOLS });
@@ -76,26 +76,29 @@ core.addTool(app_1.getProductManifestTool);
 // Marketplace app tools
 core.addTool(app_1.publishAppTool);
 core.addTool(app_1.installMarketplaceAppTool);
-// Bot-internal tools - only register when MCP_CLIENT_ENABLED=true (daemon mode)
+// Bot-internal tools - dynamically imported only when MCP_CLIENT_ENABLED=true
+// This allows npm package to work without bot-config and bug-fixer modules
 if (config_1.environment.MCP_CLIENT_ENABLED) {
-    // Bot configuration tools
-    core.addTool(bot_config_1.listBotsConfigTool);
-    core.addTool(bot_config_1.enableBotTool);
-    core.addTool(bot_config_1.disableBotTool);
-    core.addTool(bot_config_1.checkSpecialistStatusTool);
-    // Bug Fixer tools
-    core.addTool(bug_fixer_tools_1.bugFixerFindAppTool);
-    core.addTool(bug_fixer_tools_1.bugFixerListFilesTool);
-    core.addTool(bug_fixer_tools_1.bugFixerReadFileTool);
-    core.addTool(bug_fixer_tools_1.bugFixerWriteFileTool);
-    core.addTool(bug_fixer_tools_1.bugFixerApplyFixTool);
-    core.addTool(bug_fixer_tools_1.bugFixerRunBuildTool);
-    core.addTool(bug_fixer_tools_1.bugFixerGitStatusTool);
-    core.addTool(bug_fixer_tools_1.bugFixerGitPullTool);
-    core.addTool(bug_fixer_tools_1.bugFixerGitCommitTool);
-    core.addTool(bug_fixer_tools_1.bugFixerGitPushTool);
-    core.addTool(bug_fixer_tools_1.bugFixerGitRevertTool);
-    core.addTool(bug_fixer_tools_1.bugFixerPublishAppTool);
+    // Dynamic import bot-config tools
+    const { listBotsConfigTool, enableBotTool, disableBotTool, checkSpecialistStatusTool } = require('./bot-config');
+    core.addTool(listBotsConfigTool);
+    core.addTool(enableBotTool);
+    core.addTool(disableBotTool);
+    core.addTool(checkSpecialistStatusTool);
+    // Dynamic import bug-fixer tools
+    const { bugFixerFindAppTool, bugFixerListFilesTool, bugFixerReadFileTool, bugFixerWriteFileTool, bugFixerApplyFixTool, bugFixerRunBuildTool, bugFixerGitStatusTool, bugFixerGitPullTool, bugFixerGitCommitTool, bugFixerGitPushTool, bugFixerGitRevertTool, bugFixerPublishAppTool } = require('./mcp/tools/bug-fixer-tools');
+    core.addTool(bugFixerFindAppTool);
+    core.addTool(bugFixerListFilesTool);
+    core.addTool(bugFixerReadFileTool);
+    core.addTool(bugFixerWriteFileTool);
+    core.addTool(bugFixerApplyFixTool);
+    core.addTool(bugFixerRunBuildTool);
+    core.addTool(bugFixerGitStatusTool);
+    core.addTool(bugFixerGitPullTool);
+    core.addTool(bugFixerGitCommitTool);
+    core.addTool(bugFixerGitPushTool);
+    core.addTool(bugFixerGitRevertTool);
+    core.addTool(bugFixerPublishAppTool);
     logger.info('Bot-internal tools registered (MCP_CLIENT_ENABLED=true)');
 }
 logger.info('All tools registered successfully');

package/dist/mcp/tools/app-scaffold.js

@@ -507,11 +507,6 @@ exports.publishHailerAppTool = {
     async execute(args, context) {
         const path = await Promise.resolve().then(() => __importStar(require('path')));
         const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-        logger.debug('Step 0: Starting publishHailerApp execute function', {
-            hasProjectDirectory: !!args.projectDirectory,
-            hasAppId: !!args.appId,
-            publishToMarket: args.publishToMarket
-        });
         // Use provided credentials or fall back to session credentials
         const email = args.email || context.email;
         const password = args.password || context.password;
@@ -524,23 +519,14 @@ exports.publishHailerAppTool = {
                     }],
             };
         }
-        // Debug: log credential availability (not the actual values)
-        logger.debug('Step 0.5: Credentials verified', {
-            hasEmail: !!email,
-            emailLength: email?.length,
-            hasPassword: !!password,
-            passwordLength: password?.length
-        });
         try {
             const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-            // Step 1: Check if expect is installed
-            logger.debug('Step 1: Checking if expect is installed...');
+            // Check if expect is installed
             try {
                 execSync('which expect', { encoding: 'utf-8', stdio: 'pipe' });
-                logger.debug('Step 1.5: expect command found');
             }
             catch {
-                logger.error('Step 1 ERROR: expect command not found');
+                logger.error('expect command not found');
                 return {
                     content: [{
                             type: "text",
@@ -548,14 +534,11 @@ exports.publishHailerAppTool = {
                         }],
                 };
             }
-            // Step 2: Determine project directory
-            logger.debug('Step 2: Checking project directory...');
+            // Determine project directory
             const projectDir = args.projectDirectory || config_1.environment.DEV_APPS_PATH || process.cwd();
-            logger.debug('Step 2.5: Project directory resolved', { projectDir });
-            // Step 3: Check if directory exists
-            logger.debug('Step 3: Verifying project directory exists...');
+            // Check if directory exists
             if (!fs.existsSync(projectDir)) {
-                logger.error('Step 3 ERROR: Project directory does not exist', { projectDir });
+                logger.error('Project directory does not exist', { projectDir });
                 return {
                     content: [{
                             type: "text",
@@ -563,12 +546,10 @@ exports.publishHailerAppTool = {
                         }],
                 };
             }
-            logger.debug('Step 3.5: Project directory exists');
-            // Step 4: Check if package.json exists
-            logger.debug('Step 4: Checking package.json...');
+            // Check if package.json exists
             const packageJsonPath = path.join(projectDir, 'package.json');
             if (!fs.existsSync(packageJsonPath)) {
-                logger.error('Step 4 ERROR: package.json not found', { packageJsonPath });
+                logger.error('package.json not found', { packageJsonPath });
                 return {
                     content: [{
                             type: "text",
@@ -576,32 +557,20 @@ exports.publishHailerAppTool = {
                         }],
                 };
             }
-            logger.debug('Step 4.5: package.json found');
-            // Step 5: Read manifest.json to get/verify appId
-            logger.debug('Step 5: Reading manifest.json...');
+            // Read manifest.json to get/verify appId
             const manifestPath = path.join(projectDir, 'public', 'manifest.json');
             let appId = args.appId;
             let appName = 'Unknown';
             if (fs.existsSync(manifestPath)) {
-                logger.debug('Step 5.5: manifest.json file found');
                 try {
-                    logger.debug('Step 5.7: Reading manifest file content...');
                     const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
-                    logger.debug('Step 5.8: Parsing manifest JSON...');
                     const manifest = JSON.parse(manifestContent);
-                    logger.debug('Step 5.9: Manifest parsed successfully', {
-                        hasAppId: !!manifest.appId,
-                        hasName: !!manifest.name,
-                        hasVersion: !!manifest.version,
-                        hasVersionDescription: !!manifest.versionDescription
-                    });
                     if (!appId) {
                         appId = manifest.appId;
                     }
                     appName = manifest.name || appName;
-                    logger.debug('Step 5.95: Manifest data extracted', { appId, appName });
                     if (!appId) {
-                        logger.error('Step 5.97 ERROR: No appId found');
+                        logger.error('No appId found');
                         return {
                             content: [{
                                     type: "text",
@@ -609,10 +578,9 @@ exports.publishHailerAppTool = {
                                 }],
                         };
                     }
-                    // Step 6: Validate version fields are present and not empty
-                    logger.debug('Step 6: Validating version fields...');
+                    // Validate version fields are present and not empty
                     if (!manifest.version || manifest.version.trim() === '') {
-                        logger.error('Step 6 ERROR: version field missing or empty');
+                        logger.error('version field missing or empty');
                         return {
                             content: [{
                                     type: "text",
@@ -620,9 +588,8 @@ exports.publishHailerAppTool = {
                                 }],
                         };
                     }
-                    logger.debug('Step 6.5: version field OK', { version: manifest.version });
                     if (!manifest.versionDescription || manifest.versionDescription.trim() === '') {
-                        logger.error('Step 6.7 ERROR: versionDescription field missing or empty');
+                        logger.error('versionDescription field missing or empty');
                         return {
                             content: [{
                                     type: "text",
@@ -630,11 +597,10 @@ exports.publishHailerAppTool = {
                                 }],
                         };
                     }
-                    logger.debug('Step 6.9: versionDescription field OK', { versionDescription: manifest.versionDescription });
                 }
                 catch (error) {
                     const errorMessage = (0, tool_helpers_1.extractErrorMessage)(error);
-                    logger.error('Step 5 ERROR: Failed to parse manifest.json', { error: errorMessage });
+                    logger.error('Failed to parse manifest.json', { error: errorMessage });
                     return {
                         content: [{
                                 type: "text",
@@ -644,7 +610,7 @@ exports.publishHailerAppTool = {
                 }
             }
             else if (!appId) {
-                logger.error('Step 5.99 ERROR: Manifest not found and no appId provided');
+                logger.error('Manifest not found and no appId provided');
                 return {
                     content: [{
                             type: "text",
@@ -652,14 +618,11 @@ exports.publishHailerAppTool = {
                         }],
                 };
             }
-            // Step 7: Check if publish-production script exists
-            logger.debug('Step 7: Checking publish-production script...');
+            // Check if publish-production script exists
             try {
-                logger.debug('Step 7.3: Reading package.json for script...');
                 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                logger.debug('Step 7.5: package.json parsed');
                 if (!packageJson.scripts?.['publish-production']) {
-                    logger.error('Step 7 ERROR: publish-production script not found');
+                    logger.error('publish-production script not found');
                     return {
                         content: [{
                                 type: "text",
@@ -667,11 +630,10 @@ exports.publishHailerAppTool = {
                             }],
                     };
                 }
-                logger.debug('Step 7.8: publish-production script found');
             }
             catch (error) {
                 const errorMessage = (0, tool_helpers_1.extractErrorMessage)(error);
-                logger.error('Step 7 ERROR: Failed to parse package.json for scripts', { error: errorMessage });
+                logger.error('Failed to parse package.json for scripts', { error: errorMessage });
                 return {
                     content: [{
                             type: "text",
@@ -679,36 +641,28 @@ exports.publishHailerAppTool = {
                         }],
                 };
             }
-            // Step 8: Prepare response and get ready to publish
-            logger.debug('Step 8: Preparing to run publish script...');
+            // Log the start of publish
+            logger.info('Publishing app...', { appId, appName, workspace: context.workspaceCache.currentWorkspace.name });
             let responseText = `🚀 **Publishing Hailer App**\n\n`;
             responseText += `**App Name:** ${appName}\n`;
             responseText += `**App ID:** \`${appId}\`\n`;
             responseText += `**Project:** ${projectDir}\n`;
             responseText += `**Marketplace:** ${publishToMarket ? 'Yes (will get targetId)' : 'No'}\n\n`;
-            logger.debug('Step 8.5: Response header prepared');
-            // Step 9: Run the SDK publish script using `expect` for interactive automation
-            // Write expect script to temp file to avoid shell escaping issues
-            logger.debug('Step 9: Starting expect script execution process...');
+            // Run the SDK publish script using `expect` for interactive automation
             const os = await Promise.resolve().then(() => __importStar(require('os')));
             const result = await new Promise((resolve) => {
                 // Create temp expect script file
-                logger.debug('Step 9.1: Creating temp directory and script path...');
                 const tmpDir = os.tmpdir();
                 const expectScriptPath = path.join(tmpDir, `hailer-publish-${Date.now()}.exp`);
-                logger.debug('Step 9.2: Expect script path resolved', { expectScriptPath });
                 // For Tcl, use braces {} for literal strings (no escaping needed except for braces)
-                // Escape only braces in the password
-                logger.debug('Step 9.3: Escaping password for expect script...');
                 const escapedPassword = password
                     .replace(/\\/g, '\\\\')
                     .replace(/\{/g, '\\{')
                     .replace(/\}/g, '\\}');
-                logger.debug('Step 9.4: Password escaped (length: ' + escapedPassword.length + ')');
                 const expectScript = `#!/usr/bin/expect -f
 set timeout 45
 log_user 1
-exp_internal 1
+exp_internal 0
 set password {${escapedPassword}}
 puts "\\n>>> SPAWNING npm run publish-production..."
 spawn npm run publish-production
@@ -762,11 +716,8 @@ expect {
 `;
                 try {
                     // Write expect script to temp file
-                    logger.debug('Step 9.5: Writing expect script to file...');
                     fs.writeFileSync(expectScriptPath, expectScript, { mode: 0o755 });
-                    logger.debug('Step 9.6: Expect script written successfully', { fileSize: expectScript.length });
                     // Build environment
-                    logger.debug('Step 9.7: Building environment variables...');
                     const envVars = {
                         ...process.env,
                         EMAIL: email
@@ -774,8 +725,6 @@ expect {
                     if (publishToMarket) {
                         envVars.MARKET = 'true';
                     }
-                    logger.debug('Step 9.8: Environment prepared', { hasEmail: !!email, publishToMarket });
-                    logger.debug('Step 9.9: Running expect script...', { projectDir, timeout: 60000 });
                     const output = execSync(`expect "${expectScriptPath}"`, {
                         cwd: projectDir,
                         encoding: 'utf-8',
@@ -783,75 +732,58 @@ expect {
                         maxBuffer: 10 * 1024 * 1024,
                         env: envVars
                     });
-                    logger.debug('Step 9.95: Expect script completed successfully', { outputLength: output.length });
                     // Clean up temp file
-                    logger.debug('Step 9.97: Cleaning up expect script...');
                     try {
                         fs.unlinkSync(expectScriptPath);
                     }
                     catch { }
-                    logger.debug('Step 9.98: Temp file cleaned');
                     // Check if manifest was updated with targetId
-                    logger.debug('Step 9.99: Checking for manifest update with targetId...');
                     let targetId;
                     try {
                         const updatedManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
                         targetId = updatedManifest.targetId;
-                        logger.debug('Step 9.991: Manifest checked', { hasTargetId: !!targetId });
                     }
                     catch {
-                        logger.debug('Step 9.992: Could not read updated manifest');
                         // Ignore
                     }
                     if (output.includes('Published successfully')) {
-                        logger.debug('Step 9.993: Success message found in output');
                         resolve({ success: true, output, targetId });
                     }
                     else {
-                        logger.debug('Step 9.994: No success message in output');
                         resolve({ success: false, output });
                     }
                 }
                 catch (error) {
-                    logger.error('Step 9 ERROR: Expect script execution failed', {
+                    logger.error('Expect script execution failed', {
                         errorCode: error.code,
-                        signal: error.signal,
-                        hasStdout: !!error.stdout,
-                        hasStderr: !!error.stderr,
-                        errorMessage: error.message
+                        signal: error.signal
                     });
                     // Clean up temp file
-                    logger.debug('Step 9.err.1: Cleaning up after error...');
                     try {
                         fs.unlinkSync(expectScriptPath);
                     }
                     catch { }
                     const output = error.stdout || error.stderr || error.message || String(error);
-                    logger.debug('Step 9.err.2: Error output collected', { outputLength: output.length });
                     // Check for specific error messages
                     if (output.includes('not found') || output.includes('command not found')) {
-                        logger.debug('Step 9.err.3: expect command not found error detected');
                         resolve({
                             success: false,
                             output: `ERROR: expect command not found. Try: apt-get install expect (Ubuntu) or brew install expect (macOS)\n\n${output}`
                         });
                     }
                     else if (output.includes('TIMEOUT')) {
-                        logger.debug('Step 9.err.4: Timeout error detected');
                         resolve({
                             success: false,
                             output: `ERROR: expect script timed out waiting for prompts. Check your internet connection and Hailer API status.\n\n${output}`
                         });
                     }
                     else if (output.includes('INVALID PASSWORD')) {
-                        logger.debug('Step 9.err.5: Invalid password error detected');
                         resolve({
                             success: false,
                             output: `ERROR: Invalid credentials provided. Check your email and password.\n\n${output}`
                         });
                     }
                     else if (output.includes('Published successfully')) {
-                        logger.debug('Step 9.err.6: Success detected despite error code');
                         // Even if exit code is non-zero, check if it actually succeeded
                         let targetId;
                         try {
@@ -864,14 +796,12 @@ expect {
                         resolve({ success: true, output, targetId });
                     }
                     else {
-                        logger.debug('Step 9.err.7: Generic error');
                         resolve({ success: false, output });
                     }
                 }
             });
-            logger.debug('Step 10: Result received from promise', { success: result.success });
             if (!result.success) {
-                logger.error('Step 10 ERROR: Publish failed', { outputLength: result.output.length });
+                logger.error('Publish failed');
                 return {
                     content: [{
                             type: "text",
@@ -879,7 +809,8 @@ expect {
                         }],
                 };
             }
-            logger.debug('Step 10.5: Publish succeeded, building response...');
+            // Log success
+            logger.info('App published successfully', { appId, appName });
             responseText += `✅ **App Published Successfully!**\n\n`;
             if (result.targetId) {
                 responseText += `**Target ID:** \`${result.targetId}\`\n\n`;
@@ -913,7 +844,6 @@ expect {
             responseText += `     member: "network_<workspace-id>" // or team_*, user_*\n`;
             responseText += `   })\n`;
             responseText += `   \`\`\`\n`;
-            logger.debug('Step 11: Publishing complete, returning success response');
             return {
                 content: [{
                         type: "text",
@@ -923,10 +853,7 @@ expect {
         }
         catch (error) {
             const errorMessage = (0, tool_helpers_1.extractErrorMessage)(error);
-            logger.error('CRITICAL ERROR: Uncaught exception in publishHailerApp', {
-                errorMessage,
-                errorType: error instanceof Error ? error.constructor.name : typeof error
-            });
+            logger.error('Error publishing Hailer app', { error: errorMessage });
             return {
                 content: [{
                         type: "text",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hailer/mcp",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"