@hailer/mcp 0.2.2 → 0.2.4

package/.claude/hooks/interactive-mode.cjs

@@ -52,10 +52,11 @@ function processHook(data) {
     process.exit(0);
   }
 
-  const lowerPrompt = prompt.toLowerCase();
-
   // Detect task types that benefit from questions
+  // Order matters - more specific patterns first
   const taskPatterns = [
+    { pattern: /publish.*market|market.*publish|update.*market|market.*update|market.*icon|market.*listing/i, type: 'marketplace-publish', questions: ['New listing or update existing? (need productId for update)', 'Metadata only or new version with code?', 'Do you have an icon? (must upload with isPublic: true)'], skill: 'marketplace-publishing' },
+    { pattern: /publish|deploy|release|update.*app|app.*update|republish/i, type: 'app-publish', questions: ['Workspace only OR marketplace too?', 'Which app? (path or name)', 'Version bump needed?'], skill: 'publish-hailer-app' },
     { pattern: /build|create|make.*app/i, type: 'app', questions: ['What data to display?', 'What layout/components?', 'What user actions needed?'] },
     { pattern: /create|add.*insight|report/i, type: 'insight', questions: ['What metrics/aggregations?', 'Which workflows to query?', 'Any filters needed?'] },
     { pattern: /import|create.*activit|bulk/i, type: 'data', questions: ['Which workflow?', 'What field values?', 'How many records?'] },
@@ -66,6 +67,7 @@ function processHook(data) {
   const matched = taskPatterns.find(p => p.pattern.test(prompt));
 
   if (matched) {
+    const skillLine = matched.skill ? `\nLoad skill: ${matched.skill}` : '';
     const output = `
 <interactive-mode>
 BEFORE STARTING: Consider asking clarifying questions.
@@ -75,7 +77,7 @@ Suggested questions to ask user:
 ${matched.questions.map(q => `- ${q}`).join('\n')}
 
 Use AskUserQuestion tool if requirements are unclear.
-Gather specifics before spawning agents or making changes.
+Gather specifics before spawning agents or making changes.${skillLine}
 </interactive-mode>
 `;
     console.log(output);

package/.claude/skills/marketplace-publishing.md

@@ -0,0 +1,155 @@
+# Marketplace Publishing Skill
+
+<when-to-use>
+User wants to publish an app to marketplace, update marketplace listing, or change marketplace app icon/metadata.
+</when-to-use>
+
+<prerequisites>
+- `productId` - Marketplace product ID (24-char hex)
+- `appId` - The app being published (24-char hex)
+- User must be Network Admin of the workspace
+</prerequisites>
+
+<option-a>
+## Update Metadata Only (No Version Change)
+
+For updating icon, name, description without publishing new code:
+
+<step-1>
+**Upload icon as PUBLIC file**
+```javascript
+upload_files({
+  files: [{ path: "/path/to/icon.png", isPublic: true }]
+})
+```
+</step-1>
+
+<critical>
+`isPublic: true` is REQUIRED for marketplace icons to display!
+</critical>
+
+<step-2>
+**Update product metadata**
+```javascript
+publish_app({
+  appId: "<appId>",
+  productId: "<productId>",  // REQUIRED for update
+  title: "App Name",
+  description: "Description",
+  version: "1.0.0",          // Current version (no bump needed)
+  versionDescription: "Release notes",
+  publisher: "Publisher Name",
+  iconFileId: "<public-file-id>"
+})
+```
+</step-2>
+</option-a>
+
+<option-b>
+## Publish New Version (Code Changes)
+
+For publishing new app code with version bump:
+
+<step-1>
+**Upload icon as PUBLIC file (if changing)**
+```javascript
+upload_files({
+  files: [{ path: "/path/to/icon.png", isPublic: true }]
+})
+```
+</step-1>
+
+<step-2>
+**Update manifest.json**
+- Bump version (must be > current, e.g., "1.0.31" → "1.0.32")
+- Update versionDescription
+</step-2>
+
+<step-3>
+**Publish app bundle**
+```javascript
+publish_hailer_app({
+  projectDirectory: "/path/to/app",
+  publishToMarket: true
+})
+```
+</step-3>
+
+<step-4>
+**Update product metadata**
+```javascript
+publish_app({
+  appId: "<appId>",
+  productId: "<productId>",
+  title: "App Name",
+  description: "Description",
+  version: "1.0.32",
+  versionDescription: "What's new",
+  publisher: "Publisher Name",
+  iconFileId: "<public-file-id>"
+})
+```
+</step-4>
+</option-b>
+
+<option-c>
+## First-Time Marketplace Listing
+
+For apps not yet in marketplace:
+
+<step-1>
+**Upload icon as PUBLIC**
+```javascript
+upload_files({
+  files: [{ path: "/path/to/icon.png", isPublic: true }]
+})
+```
+</step-1>
+
+<step-2>
+**Publish app with marketplace flag**
+```javascript
+publish_hailer_app({
+  projectDirectory: "/path/to/app",
+  publishToMarket: true
+})
+```
+Returns a `targetId`.
+</step-2>
+
+<step-3>
+**Create marketplace listing**
+```javascript
+publish_app({
+  appId: "<appId>",
+  versionId: "<targetId>",   // From step 2
+  title: "App Name",
+  description: "Description",
+  version: "1.0.0",
+  versionDescription: "Initial release",
+  publisher: "Publisher Name",
+  iconFileId: "<public-file-id>"
+})
+```
+</step-3>
+
+<note>
+Creating new listings requires admin permissions.
+</note>
+</option-c>
+
+<common-errors>
+| Error | Cause | Fix |
+|-------|-------|-----|
+| Icon shows placeholder | File not public | Re-upload with `isPublic: true` |
+| "You have to be a network admin" | Missing permissions | Get admin access |
+| "Version not greater than previous" | Version too low | Bump version higher |
+| POST /app/publish fails | Needs file upload | Use `publish_hailer_app` for code changes |
+</common-errors>
+
+<api-reference>
+- `v3.product.update` - Updates metadata (name, description, icon, images)
+- `v3.product.create` - Creates new listing (admin only)
+- `POST /app/publish` - Uploads app bundle (requires .tgz file)
+- `v3.app.product.install` - Installs/updates in workspace
+</api-reference>

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

@@ -812,37 +812,15 @@ exports.publishAppTool = {
                 };
             }
             let productId = args.productId;
-            let targetId = args.versionId;
-            // Step 1: If no versionId provided and not updating, create app version manifest
-            if (!targetId && !productId) {
-                const publishData = {
-                    appId: args.appId,
-                    workspaceId,
-                    version: args.version,
-                    versionDescription: args.versionDescription,
-                    title: args.title,
-                    description: args.description
+            const targetId = args.versionId;
+            // For new listings, we need both targetId (from publish_hailer_app) to create the product
+            if (!productId && !targetId) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Error**: Missing required IDs.\n\n**To create a new marketplace listing:**\n1. Run \`publish_hailer_app\` with \`publishToMarket: true\` to get a targetId\n2. Then run \`publish_app\` with the \`versionId\` (targetId)\n\n**To update existing listing metadata (icon, name, etc.):**\nInclude the \`productId\` parameter - no version bump needed.`,
+                        }],
                 };
-                logger.debug('Calling v2.network.product.publishAppVersion', { publishData });
-                try {
-                    const publishResult = await context.hailer.request('v2.network.product.publishAppVersion', [publishData]);
-                    logger.debug('publishAppVersion response', { result: JSON.stringify(publishResult) });
-                    targetId = publishResult?.productId || publishResult?._id || publishResult?.id;
-                }
-                catch (err) {
-                    logger.debug('v2.network.product.publishAppVersion failed', {
-                        error: err instanceof Error ? err.message : String(err)
-                    });
-                    // If publishAppVersion doesn't exist, the error will be caught below
-                }
-                if (!targetId) {
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `❌ **Error**: Could not create app version for marketplace.\n\n**Note:** The app marketplace publishing API may not be available. Make sure the app has been published with \`publish_hailer_app\` first.\n\nYou can share the app directly with \`add_app_member\` instead.`,
-                            }],
-                    };
-                }
             }
             // Step 2: Create or Update the product in marketplace
             let productData;
@@ -881,9 +859,9 @@ exports.publishAppTool = {
                 apiMethod = 'v3.product.create';
                 apiArgs = [productData];
             }
-            logger.debug(`Calling ${apiMethod}`, { productId, workspaceId, appId: args.appId, targetId, iconFileId: args.iconFileId });
+            logger.info(`Calling ${apiMethod}`, { productId, workspaceId, appId: args.appId, targetId, productData });
             const apiResult = await context.hailer.request(apiMethod, apiArgs);
-            logger.debug(`${apiMethod} response`, {
+            logger.info(`${apiMethod} response`, {
                 result: JSON.stringify(apiResult)
             });
             // Get the final product ID from the v3 API response

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.2",
+  "version": "0.2.4",
   "config": {
     "docker": {
       "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"