frontmcp 1.1.0 → 1.1.2-beta.1

package/src/commands/build/exec/cli-runtime/generate-cli-entry.js

@@ -8,6 +8,7 @@ exports.RESERVED_COMMANDS = void 0;
 exports.resolveToolCommandName = resolveToolCommandName;
 exports.generateCliEntry = generateCliEntry;
 exports.extractTemplateParams = extractTemplateParams;
+const extract_public_message_snippet_1 = require("./extract-public-message.snippet");
 const schema_extractor_1 = require("./schema-extractor");
 const schema_to_commander_1 = require("./schema-to-commander");
 exports.RESERVED_COMMANDS = new Set([
@@ -15,6 +16,9 @@ exports.RESERVED_COMMANDS = new Set([
     'login', 'logout', 'connect', 'serve', 'daemon',
     'doctor', 'install', 'uninstall', 'sessions', 'help', 'version',
     'skills', 'job', 'workflow',
+    // Reserved by the symmetric `prompt get <name>` / `resource read <uri>`
+    // sub-API; included so a user-defined entry can never shadow them.
+    'get', 'list', 'read',
 ]);
 /**
  * Resolve tool command name, appending '-tool' suffix if it conflicts with a built-in command.
@@ -193,7 +197,31 @@ async function closeClient() {
 // Flag set by long-running commands (serve, daemon) to prevent the footer from calling process.exit().
 var _isLongRunning = false;
 
+${extract_public_message_snippet_1.EXTRACT_PUBLIC_MESSAGE_SNIPPET}
+
 var program = new Command();
+// Make Commander's own usage errors (unknown subcommand, missing required option,
+// invalid value) exit with code 2 instead of the default 0 — matches POSIX
+// convention and lets shell scripts/CI distinguish runtime failures from usage.
+//
+// Sets process.exitCode and re-throws so the parseAsync() footer can run
+// closeClient() / native-addon teardown before the actual exit. Calling
+// process.exit() directly here would skip that and could leave better-sqlite3
+// / ONNX / file handles in a corrupt state for short-lived runs.
+program.exitOverride(function(err) {
+  if (err.code === 'commander.helpDisplayed' || err.code === 'commander.help' || err.code === 'commander.version') {
+    process.exitCode = 0;
+  } else if (err.code === 'commander.unknownCommand' || err.code === 'commander.unknownOption' ||
+      err.code === 'commander.missingArgument' || err.code === 'commander.missingMandatoryOptionValue' ||
+      err.code === 'commander.invalidArgument' || err.code === 'commander.optionMissingArgument' ||
+      err.code === 'commander.invalidOptionArgument' || err.code === 'commander.excessArguments') {
+    process.exitCode = 2;
+  } else {
+    process.exitCode = 1;
+  }
+  // Re-throw so parseAsync().catch in the footer runs cleanup before exit.
+  throw err;
+});
 program
   .name(${JSON.stringify(appName)})
   .version(${JSON.stringify(appVersion)})
@@ -280,16 +308,28 @@ ${optionLines}
       var result = await client.callTool(${JSON.stringify(tool.name)}, args);
       var mode = program.opts().output || ${JSON.stringify('text')};
       console.log(fmt.formatToolResult(result, mode));
+      // The SDK converts thrown errors into a CallToolResult with isError:true
+      // (so HTTP/JSON-RPC clients still get a structured response). Detect
+      // that here and map to a non-zero exit code so shell scripts can gate
+      // on success — Zod input validation errors → exit 2 (usage), all
+      // other tool errors → exit 1 (runtime).
+      if (result && result.isError === true) {
+        var rmeta = (result && result._meta) || {};
+        process.exitCode = (rmeta.code === 'INVALID_INPUT') ? 2 : 1;
+      }
     } catch (err) {
       var meta = err && err._meta ? err._meta : (err && err.data && err.data._meta ? err.data._meta : null);
       if (meta && meta.authorization_required) {
         console.error('Authorization required' + (meta.app ? ' for ' + meta.app : ''));
         if (meta.auth_url) console.error('Authorize at: ' + meta.auth_url);
         console.error('Or run: ' + ${JSON.stringify(appName)} + ' login');
+        process.exitCode = 1;
       } else {
-        console.error('Error:', err.message || err);
+        // Thrown error path (transport / DI / pre-flow failure) — same
+        // mapping as the isError result path above.
+        var isUsage = err && err.code === 'INVALID_INPUT';
+        _exitWithError(err, isUsage ? 2 : 1);
       }
-      process.exitCode = 1;
     }
   });`;
     });
@@ -362,8 +402,7 @@ resourceCmd
         });
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -377,8 +416,7 @@ resourceCmd
       var mode = program.opts().output || 'text';
       console.log(fmt.formatResourceResult(result, mode));
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
 }
@@ -412,8 +450,7 @@ ${optionLines}
       var mode = program.opts().output || 'text';
       console.log(fmt.formatResourceResult(result, mode));
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
     });
@@ -437,14 +474,44 @@ templateCmd
         });
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
 ${subcommands.join('\n\n')}`;
 }
 function generatePromptCommands(prompts) {
+    // Map known prompts → option specs so `prompt get <name>` knows which flags
+    // to accept per prompt. Unknown prompt names still call getPrompt() and
+    // surface the server's error to the user.
+    const promptArgsMap = prompts.map((p) => {
+        const args = (p.arguments || []).map((a) => ({
+            name: a.name,
+            kebab: (0, schema_to_commander_1.camelToKebab)(a.name),
+            camel: kebabToCamel((0, schema_to_commander_1.camelToKebab)(a.name)),
+            required: !!a.required,
+        }));
+        return `${JSON.stringify(p.name)}: ${JSON.stringify(args)}`;
+    }).join(',\n      ');
+    // #382 round-2 — collect the union of all known prompt-arg kebab names so we
+    // can register them as `.option(--<name> <value>)` on `prompt get`. Without
+    // these registrations, Commander treats the value tokens (e.g. `add` after
+    // `--op`) as extra positional args and rejects them with
+    // `too many arguments for 'get'. Expected 1 argument but got 7.` —
+    // breaking every prompt that takes arguments. Per-prompt validation still
+    // happens inside the action handler against `promptArgs[name]`, so a user
+    // that types `--op` for a prompt that doesn't declare it gets a clear
+    // "unknown option(s) for prompt" error rather than silent acceptance.
+    const allKebabNames = new Set();
+    for (const p of prompts) {
+        for (const a of p.arguments || []) {
+            allKebabNames.add((0, schema_to_commander_1.camelToKebab)(a.name));
+        }
+    }
+    const promptGetOptionLines = Array.from(allKebabNames)
+        .sort()
+        .map((kebab) => `  .option(${JSON.stringify(`--${kebab} <value>`)}, '')`)
+        .join('\n');
     const subcommands = prompts.map((prompt) => {
         const cmdName = (0, schema_to_commander_1.camelToKebab)(prompt.name).replace(/_/g, '-');
         const argOptions = (prompt.arguments || [])
@@ -458,7 +525,7 @@ function generatePromptCommands(prompts) {
             .join('\n');
         return `promptCmd
   .command(${JSON.stringify(cmdName)})
-  .description(${JSON.stringify(prompt.description || '')})
+  .description(${JSON.stringify((prompt.description || '') + ' (deprecated alias — use `prompt get ' + cmdName + '`)')})
 ${argOptions}
   .action(async function(opts) {
     try {
@@ -473,8 +540,7 @@ ${argOptions}
       var mode = program.opts().output || 'text';
       console.log(fmt.formatPromptResult(result, mode));
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
     });
@@ -498,8 +564,94 @@ promptCmd
         });
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
+    }
+  });
+
+// Symmetric \`prompt get <name>\` to mirror \`resource read <uri>\`. Looks up
+// per-prompt argument metadata from \`promptArgs\` and forwards as MCP
+// \`prompts/get\` request arguments. Unknown / missing required flags exit 2.
+//
+// Robust flag parser supports:
+//   --key value         (canonical form)
+//   --key=value         (single-token form)
+//   --bool              (boolean — value defaults to "true")
+//   --                  (end-of-options marker; everything after is ignored)
+// Unknown flags fail-fast with exit 2 instead of being silently dropped.
+var promptArgs = {
+      ${promptArgsMap}
+    };
+var _getCmd = promptCmd
+  .command('get <name>')
+  .description('Render a prompt by name')
+${promptGetOptionLines}
+  .allowUnknownOption(true)
+  .action(async function(name) {
+    try {
+      var spec = promptArgs[name];
+      if (!spec) {
+        console.error('Error: Unknown prompt: ' + name);
+        process.exitCode = 1;
+        return;
+      }
+      // Commander parsed registered options into rawOpts (camelCased). For
+      // unregistered prompts (a flag a different prompt declares but this one
+      // doesn't), fall back to scanning the raw token stream — that way an
+      // out-of-spec --foo for "this" prompt still surfaces as an explicit
+      // "unknown option(s)" error rather than being silently dropped.
+      var rawOpts = this.opts();
+      var rawTokens = this.args.slice(1);
+      var args = {};
+      var unknown = [];
+      var byKebab = {};
+      var byCamel = {};
+      for (var s = 0; s < spec.length; s++) {
+        byKebab[spec[s].kebab] = spec[s];
+        byCamel[spec[s].camel] = spec[s];
+      }
+      // 1. Pull values from Commander-parsed options (registered names).
+      for (var camelKey in rawOpts) {
+        if (Object.prototype.hasOwnProperty.call(rawOpts, camelKey)) {
+          var matchByCamel = byCamel[camelKey];
+          if (matchByCamel) {
+            args[matchByCamel.name] = rawOpts[camelKey];
+          }
+        }
+      }
+      // 2. Scan rawTokens for any --<flag> not in this prompt's spec — those
+      //    are real "unknown for this prompt" errors. (Commander already
+      //    consumed the registered ones; only out-of-spec flags survive here
+      //    via .allowUnknownOption(true).)
+      for (var i = 0; i < rawTokens.length; i++) {
+        var tok = rawTokens[i];
+        if (tok === '--') break;
+        if (typeof tok !== 'string' || tok.indexOf('--') !== 0) continue;
+        var keyAndVal = tok.slice(2);
+        var eq = keyAndVal.indexOf('=');
+        var key = eq >= 0 ? keyAndVal.slice(0, eq) : keyAndVal;
+        if (!byKebab[key]) {
+          unknown.push('--' + key);
+        }
+      }
+      if (unknown.length > 0) {
+        console.error('Error: unknown option(s) for prompt "' + name + '": ' + unknown.join(', '));
+        process.exitCode = 2;
+        return;
+      }
+      // 3. Validate required args.
+      for (var r = 0; r < spec.length; r++) {
+        if (spec[r].required && args[spec[r].name] === undefined) {
+          console.error('Error: missing required option --' + spec[r].kebab);
+          process.exitCode = 2;
+          return;
+        }
+      }
+      var client = await getClient();
+      var result = await client.getPrompt(name, args);
+      var mode = program.opts().output || 'text';
+      console.log(fmt.formatPromptResult(result, mode));
+    } catch (err) {
+      _exitWithError(err, 1);
     }
   });
 
@@ -535,8 +687,7 @@ skillsCmd
         console.log("  Use '" + program.name() + " skills load <name>' to load a skill.\\n");
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -557,8 +708,7 @@ skillsCmd
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -594,8 +744,7 @@ skillsCmd
         console.log("  Load: " + program.name() + " skills load " + name + '\\n');
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -623,8 +772,7 @@ skillsCmd
         console.log("  Use '" + program.name() + " skills read <name>' for full details.\\n");
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
 }
@@ -659,8 +807,7 @@ ${optionLines}
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
         }
@@ -690,8 +837,7 @@ ${optionLines}
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
     });
@@ -721,8 +867,7 @@ ${optionLines}
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
     return `var jobCmd = program.command('job').description('Job operations');
@@ -749,8 +894,7 @@ jobCmd
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -782,8 +926,7 @@ ${jobs.length > 0 ? genericRun : `jobRunCmd
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`}
 
@@ -801,8 +944,7 @@ jobCmd
         console.log('Status: ' + (result.status || JSON.stringify(result)));
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
 }
@@ -831,8 +973,7 @@ workflowCmd
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -861,8 +1002,7 @@ workflowCmd
         }
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -880,8 +1020,7 @@ workflowCmd
         console.log('Status: ' + (result.status || JSON.stringify(result)));
       }
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
 }
@@ -933,8 +1072,7 @@ subscribeCmd
       setInterval(function() {}, 2147483647);
       await new Promise(function() {});
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });
 
@@ -962,8 +1100,7 @@ subscribeCmd
       setInterval(function() {}, 2147483647);
       await new Promise(function() {});
     } catch (err) {
-      console.error('Error:', err.message || err);
-      process.exitCode = 1;
+      _exitWithError(err, 1);
     }
   });`;
 }
@@ -1521,9 +1658,20 @@ program.parseAsync(process.argv).then(async function() {
   // (ONNX runtime, etc.) can release mutexes before V8 tears down.
   setImmediate(function() { process.exit(process.exitCode || 0); });
 }).catch(async function(err) {
-  console.error('Fatal:', err.message || err);
+  // Commander errors come through exitOverride with the code already set on
+  // process.exitCode. They are user-facing usage errors, not fatals — don't
+  // re-print "Fatal:" / "Unknown error" for them.
+  var isCommanderErr = err && typeof err.code === 'string' && err.code.indexOf('commander.') === 0;
+  if (!isCommanderErr) {
+    console.error('Fatal:', err.message || err);
+  }
   await closeClient();
-  process.exit(1);
+  // Use the exit code set by exitOverride (which can legitimately be 0 for
+  // --help / --version). Only fall back to 1 when no code was set.
+  setImmediate(function() {
+    var code = (typeof process.exitCode === 'number') ? process.exitCode : 1;
+    process.exit(code);
+  });
 });`;
 }
 /**