jovo-cli
Version:
jovo command line tool (beta)
287 lines • 11 kB
JavaScript
;
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const command_1 = __importStar(require("@oclif/command"));
const boxen_1 = __importStar(require("boxen"));
const chalk_1 = __importDefault(require("chalk"));
const cross_spawn_1 = __importDefault(require("cross-spawn"));
const fs_extra_1 = require("fs-extra");
const jovo_cli_core_1 = require("jovo-cli-core");
const JovoWebhookConnector = __importStar(require("jovo-webhook-connector"));
const lodash_1 = __importDefault(require("lodash"));
const open_1 = __importDefault(require("open"));
const path = __importStar(require("path"));
const resolve_bin_1 = __importDefault(require("resolve-bin"));
const utils_1 = require("../utils");
class Run extends command_1.default {
async run() {
utils_1.platforms.addCliOptions('run', Run.flags);
utils_1.addBaseCliOptions(Run.flags);
this.log(' ');
const { args, flags } = this.parse(Run);
if (!utils_1.platforms.validateCliOptions('run', flags)) {
return;
}
this.log(`\n jovo run: ${Run.description}`);
this.log(chalk_1.default.grey(' >> Learn more: https://jovo.tech/docs/cli/run\n'));
const project = jovo_cli_core_1.getProject();
await project.init();
const port = Number(flags.port) || 3000;
const timeout = flags.timeout || 5000;
const stage = project.getStage(flags.stage);
if (utils_1.shouldDisplayUpdateMessage(24)) {
const packageVersions = await utils_1.getPackageVersionsNpm(/^jovo\-/);
const outOfDatePackages = [];
if (Object.keys(packageVersions).length > 0) {
for (const packageName of Object.keys(packageVersions)) {
if (packageVersions[packageName].local !== packageVersions[packageName].npm) {
outOfDatePackages.push(packageName);
}
}
}
if (outOfDatePackages.length > 0) {
const outputText = [];
outputText.push('Updates available for the following Jovo packages:');
for (const packageName of outOfDatePackages) {
const text = ` - ${packageName}: ${packageVersions[packageName].local} ${chalk_1.default.grey(`-> ${packageVersions[packageName].npm}`)}`;
outputText.push(text);
}
outputText.push('\nUse "jovo update" to get the newest versions.');
const boxOptions = {
padding: 1,
margin: 1,
borderColor: 'yellow',
borderStyle: "round",
};
this.log(boxen_1.default(outputText.join('\n'), boxOptions));
utils_1.setUpdateMessageDisplayed();
}
}
try {
project.getConfig(stage);
}
catch (err) {
throw new jovo_cli_core_1.JovoCliError(err.message, 'jovo-cli');
}
if (flags['webhook-only']) {
return jovoWebhook({ port, timeout }, stage);
}
let srcDir = project.jovoConfigReader.getConfigParameter('src', stage);
if (srcDir && !lodash_1.default.endsWith(path.sep, srcDir)) {
srcDir += path.sep;
}
const checkFolders = ['./'];
if (srcDir) {
checkFolders.push(srcDir);
}
if (flags.tsc) {
this.log('Compiling TypeScript...');
await project.compileTypeScriptProject(srcDir);
this.log('TypeScript Compiling finished.');
}
if (await project.isTypeScriptProject()) {
checkFolders.push('./dist/src/');
checkFolders.push('./dist/');
try {
fs_extra_1.accessSync(path.join('./dist/'));
}
catch (e) {
this.log('Cannot find /dist folder. Start compiling TypeScript...');
await project.compileTypeScriptProject(srcDir);
this.log('TypeScript Compiling finished.');
this.log(' ');
}
}
else {
checkFolders.push('./src/');
}
let projectFolder;
for (const folderPath of checkFolders) {
try {
fs_extra_1.accessSync(path.join(folderPath, args.webhookFile));
projectFolder = folderPath;
}
catch (err) {
}
}
if (!projectFolder) {
this.error('Could not find a project to run.');
}
const parameters = [
args.webhookFile,
'--ignore',
'db/*',
'--ignore',
'test/*',
'--webhook',
'--jovo-webhook',
];
if (flags.record) {
parameters.push('--record', flags.record);
}
if (flags.inspect) {
parameters.unshift(`--inspect=${flags.inspect}`);
}
if (srcDir && srcDir.length > 0) {
parameters.push('--projectDir', process.cwd());
}
if (stage) {
parameters.push('--stage', stage);
}
if (flags['disable-jovo-debugger']) {
parameters.push('--disable-jovo-debugger');
}
if (flags['model-test']) {
parameters.push('--model-test');
}
if (flags.port) {
parameters.push('--port', flags.port);
}
parameters.push('--color');
let addActive = false;
for (const parameter of process.argv) {
if (addActive) {
parameters.push(parameter);
}
else if (parameter === '--') {
addActive = true;
}
}
const command = flags.watch ? resolve_bin_1.default.sync('nodemon') : 'node';
const ls = cross_spawn_1.default(command, parameters, {
windowsVerbatimArguments: true,
cwd: projectFolder,
});
jovoWebhook({ port, timeout }, stage, ls);
ls.on('close', (code) => {
if (code !== 0) {
process.exit(-1);
}
});
ls.stdout.pipe(process.stdout);
ls.stderr.pipe(process.stderr);
process.on('exit', () => {
ls.kill();
});
}
}
exports.Run = Run;
Run.description = 'Runs a local development server (webhook).';
Run.examples = ['jovo run --watch', 'jovo run --port 8008'];
Run.flags = {
'port': command_1.flags.string({
char: 'p',
description: 'Port to local development webhook.',
}),
'inspect': command_1.flags.string({
char: 'i',
description: 'Debugging port.',
}),
'stage': command_1.flags.string({
description: 'Takes configuration from specified stage.',
}),
'watch': command_1.flags.boolean({
char: 'w',
description: 'Uses nodemon to watch files. Restarts immediately on file change.',
}),
'webhook-only': command_1.flags.boolean({
description: 'Starts the Jovo Webhook proxy without executing the code.',
}),
'tsc': command_1.flags.boolean({
description: 'Compile TypeScript first before execution.',
}),
'disable-jovo-debugger': command_1.flags.boolean({
description: 'Disables Jovo Debugger (web version).',
}),
'model-test': command_1.flags.boolean({
description: 'Activates the language model test.',
}),
'timeout': command_1.flags.integer({
description: 'Sets timeout in milliseconds.',
}),
'record': command_1.flags.string({
char: 'r',
description: 'Can be used to record requests and responses of your Jovo app for testing purposes.',
}),
};
Run.args = [{ name: 'webhookFile', required: false, default: 'index.js' }];
function jovoWebhook(options, stage, childProcess) {
const project = jovo_cli_core_1.getProject();
let id;
try {
id = project.getOrCreateJovoWebhookId();
}
catch (err) {
console.log('Warning: Please initialize your project: $ jovo3 init');
return;
}
try {
if (!project.jovoConfigReader.getConfigParameter('endpoint', stage)) {
}
if (lodash_1.default.startsWith(project.jovoConfigReader.getConfigParameter('endpoint', stage), 'arn')) {
throw new jovo_cli_core_1.JovoCliError("Warning: Your endpoint is a lambda endpoint. Lambda isn't supported with jovo webhook.", 'jovo-cli');
}
}
catch (err) {
if (lodash_1.default.startsWith(err.message, 'Warning:')) {
console.log(err.message);
}
}
JovoWebhookConnector.open(id, jovo_cli_core_1.JOVO_WEBHOOK_URL, { post: options });
const debuggerUrl = `${jovo_cli_core_1.JOVO_WEBHOOK_URL}/${id}`;
if (Boolean(process.stdout.isTTY)) {
if (process.stdin.setRawMode) {
setTimeout(() => {
console.log('\nTo open Jovo Debugger in your browser, enter .\n');
}, 2500);
process.stdin.setRawMode(true);
process.stdin.resume();
process.stdin.setEncoding('utf8');
let inputText = '';
process.stdin.on('data', async (keyRaw) => {
const key = keyRaw.toString();
if (key === '.') {
try {
await open_1.default(debuggerUrl);
}
catch (e) {
console.log('\nCould not open browser. Please open debugger manually by visiting this url:');
console.log(debuggerUrl);
}
inputText = '';
}
else {
if (key.charCodeAt(0) === 13) {
if (childProcess) {
childProcess.stdin.write(inputText + '\n');
}
process.stdout.write('\n');
inputText = '';
}
else if (key.charCodeAt(0) === 3) {
process.exit();
}
else {
inputText += key;
process.stdout.write(key);
}
}
});
}
else {
setTimeout(() => {
console.log(`\nTo open Jovo Debugger open this url in your browser:\n${debuggerUrl}\n`);
}, 2500);
}
}
}
//# sourceMappingURL=run.js.map