1401 lines
65 KiB
JavaScript
1401 lines
65 KiB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.bebe = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
(function (global,__dirname){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo = require("jibo");
|
|
const jibo_log_1 = require("jibo-log");
|
|
const path = require("path");
|
|
const be_framework_1 = require("@be/be-framework");
|
|
const TimerSpy_1 = require("./TimerSpy");
|
|
const jibo_client_framework_1 = require("jibo-client-framework");
|
|
const log_1 = require("./log");
|
|
const SkillSwitchScheduler_1 = require("./SkillSwitchScheduler");
|
|
const SkillLifecycleState_1 = require("./SkillLifecycleState");
|
|
const SkillLifecycleEndState_1 = require("./SkillLifecycleEndState");
|
|
const SkillSwitchData_1 = require("./SkillSwitchData");
|
|
const SkillRedirectToken_1 = require("./SkillRedirectToken");
|
|
const SkillLifecycle_1 = require("./SkillLifecycle");
|
|
const SkillSwitchUtil_1 = require("./SkillSwitchUtil");
|
|
const ModuleVersions_1 = require("./ModuleVersions");
|
|
const LibraryAnalytics_1 = require("./LibraryAnalytics");
|
|
const DateSetter_1 = require("./DateSetter");
|
|
const url = require("url");
|
|
jibo.utils.LocationUtils.setLocationLookupKey('Ri2CIo95Sa7dlwft5tQPixUtnPo=');
|
|
jibo.utils.LocationUtils.setCapitalLookupKey('LLK5HQ-GJ5AULXWH6');
|
|
jibo.utils.Timezone.setLocationLookupKey('Ri2CIo95Sa7dlwft5tQPixUtnPo=');
|
|
class Be {
|
|
constructor() {
|
|
global.be = this;
|
|
this.log = log_1.default.createChild("Be");
|
|
this.log.info("%c Welcome to: BE SKILL ", 'font-weight:bold;color:white;padding:5px 20px;background-color:purple;border-radius:20px');
|
|
let splash = document.createElement('div');
|
|
splash.id = 'splash';
|
|
document.body.insertBefore(splash, document.getElementById('face'));
|
|
this.skills = {};
|
|
this.packageInfo = require(path.join(jibo.utils.PathUtils.findRoot(), 'package.json'));
|
|
this.packageInfo.jibo.skills.forEach((id) => {
|
|
try {
|
|
const startTime = Date.now();
|
|
const SkillExport = require(id);
|
|
let Skill;
|
|
if (typeof SkillExport === 'function') {
|
|
Skill = SkillExport;
|
|
}
|
|
else if (typeof SkillExport.Skill === 'function') {
|
|
Skill = SkillExport.Skill;
|
|
}
|
|
else {
|
|
throw new Error(`Error loading skill: ${id}. Incorrect exports`);
|
|
}
|
|
const skill = new Skill({
|
|
assetPack: id,
|
|
rootPath: path.dirname(jibo.utils.PathUtils.resolve(id))
|
|
});
|
|
if (!this._validateSkill(skill)) {
|
|
throw new Error('not a valid BeSkill');
|
|
}
|
|
this.skills[id] = skill;
|
|
this.log.info(`loading - skill construction ${id} - ${Date.now() - startTime} MS`);
|
|
}
|
|
catch (err) {
|
|
this.log.error(`Skill creation for '${id}' failed: ${err}`);
|
|
}
|
|
});
|
|
this.idle = this.skills[this.packageInfo.jibo.defaultSkill];
|
|
this.firstSkill = this.skills[this.packageInfo.jibo.firstSkill];
|
|
this.restoreSkill = this.skills[this.packageInfo.jibo.restoreSkill];
|
|
this.eosSkill = this.skills[this.packageInfo.jibo.eosSkill];
|
|
this.log.debug('creating skills switch scheduler');
|
|
this._skillSwitchScheduler = new SkillSwitchScheduler_1.default(this.idle);
|
|
const empty = (done) => { done(); };
|
|
const eosCategories = [];
|
|
for (let id in this.skills) {
|
|
this.log.debug('listening for when skill finishes', id);
|
|
const skill = this.skills[id];
|
|
skill.on('exit', function () {
|
|
this.exit.call(this, skill, ...arguments);
|
|
}.bind(this));
|
|
skill.on('redirect', function () {
|
|
this.skillRedirect.call(this, skill, ...arguments);
|
|
}.bind(this));
|
|
skill.on('refresh', function () {
|
|
this.skillRedirect.call(this, skill, skill.assetPack, ...arguments);
|
|
}.bind(this));
|
|
if (skill.isElementOfSurprise) {
|
|
eosCategories.push(skill);
|
|
}
|
|
if (!skill.postInit) {
|
|
skill.postInit = empty;
|
|
}
|
|
if (!skill.preload) {
|
|
skill.preload = empty;
|
|
}
|
|
}
|
|
this.log.debug('calling supplyCategories');
|
|
this.eosSkill.supplyCategories(eosCategories);
|
|
this.log.debug('bottom of Be constructor');
|
|
}
|
|
init(initDoneCallback) {
|
|
this.initDoneCallback = initDoneCallback;
|
|
ModuleVersions_1.default.log(this.log, jibo.utils.PathUtils.findRoot());
|
|
this.log.debug('Initting jibo');
|
|
jibo.init({ display: 'face', analytics: new LibraryAnalytics_1.default() }, (err) => {
|
|
if (err) {
|
|
this.log.error(err);
|
|
this.initDoneCallback(err);
|
|
return;
|
|
}
|
|
this.log.debug('Jibo initted');
|
|
window.Module = null;
|
|
this.log.debug('loading log config');
|
|
log_1.loadLogConfig(err => {
|
|
if (err) {
|
|
this.log.warn(err);
|
|
}
|
|
this.log.debug('loaded log config');
|
|
const hostUrl = url.parse(jibo.registryHost);
|
|
jibo_client_framework_1.RegistryClient.createInstance(hostUrl.hostname, parseInt(hostUrl.port));
|
|
this.log.debug('initting NotificationsDispatcher');
|
|
jibo_client_framework_1.NotificationsDispatcher.instance.init(err => {
|
|
if (err) {
|
|
this.log.warn('Problem initializing; notifications disabled');
|
|
}
|
|
this.log.debug('inited NotificationsDispatcher', err);
|
|
if (!err) {
|
|
this.log.debug('Calling handleLogLevelNotifications');
|
|
}
|
|
const promise = err
|
|
? Promise.resolve()
|
|
: jibo_log_1.Log.handleLogLevelNotifications(jibo_client_framework_1.NotificationsDispatcher.instance);
|
|
promise.catch(err => this.log.warn(err)).then(() => {
|
|
this.log.debug('Done handling log level notifications');
|
|
if (this.packageInfo.jibo.debug.resourceLeak) {
|
|
TimerSpy_1.default.instance.init(() => {
|
|
if (this._skillSwitchScheduler.currentSkillRedirectToken) {
|
|
return this._skillSwitchScheduler.currentSkillRedirectToken.skillSwitchData.skill.assetPack;
|
|
}
|
|
else {
|
|
return "";
|
|
}
|
|
});
|
|
}
|
|
this._skillSwitchScheduler.run();
|
|
this.log.info("Indexing...");
|
|
jibo.expression.indexRobot().then(() => {
|
|
this.log.info('initialize the BeSkill.plugins');
|
|
be_framework_1.BeSkill.init(this.initPlugins.bind(this));
|
|
}).catch(() => {
|
|
be_framework_1.BeSkill.errorCode('F4-Index_timeout', 'Initial indexing error in Be: ' + err);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
initPlugins(err) {
|
|
if (err) {
|
|
this.log.error('Error BeSkill plugins: ', err);
|
|
this.initDoneCallback(err);
|
|
return;
|
|
}
|
|
const tasks = [];
|
|
for (let id in this.skills) {
|
|
const skill = this.skills[id];
|
|
this.log.debug(`About to push task for skill ${id}`);
|
|
tasks.push((done) => {
|
|
const startTime = Date.now();
|
|
this.log.debug(`Calling postInit for skill ${id}`);
|
|
skill.postInit.bind(skill)((err) => {
|
|
if (err) {
|
|
this.log.error(`error during skill ${skill.assetPack} postinit call:`, err);
|
|
}
|
|
this.log.info(`loading - skill ${skill.assetPack} postinit call - ${Date.now() - startTime} MS`);
|
|
done();
|
|
});
|
|
});
|
|
}
|
|
this.log.debug('calling jibo loader to load the skills');
|
|
jibo.loader.load(tasks, this.postInit.bind(this));
|
|
}
|
|
initAnalyticsContext() {
|
|
let context = {
|
|
ssm_version: "<not set>",
|
|
be_version: "<not set>",
|
|
platform_version: "<not set>",
|
|
release_version: "<not set>"
|
|
};
|
|
this.log.debug('context', JSON.stringify(context));
|
|
this.log.debug('calling jibo.versions');
|
|
const versions = jibo.versions;
|
|
this.log.debug('got jibo.versions', JSON.stringify(versions));
|
|
if (versions) {
|
|
context.platform_version = versions.platform;
|
|
context.ssm_version = versions.ssm;
|
|
context.release_version = versions.release;
|
|
}
|
|
this.log.debug('getting Be version');
|
|
const dir = jibo.utils.PathUtils.findRoot(__dirname);
|
|
const beVersion = require(path.resolve(dir, 'package.json')).version;
|
|
this.log.debug('got version:', beVersion);
|
|
context.be_version = beVersion;
|
|
this.log.debug('version set on context');
|
|
this.log.debug('setting context on BeSkill');
|
|
this.log.debug(!!be_framework_1.BeSkill);
|
|
this.log.debug(!!be_framework_1.BeSkill.plugins);
|
|
this.log.debug(!!be_framework_1.BeSkill.plugins.analytics);
|
|
this.log.debug(!!be_framework_1.BeSkill.plugins.analytics.context);
|
|
be_framework_1.BeSkill.plugins.analytics.context = context;
|
|
this.log.debug('context set on BeSkill analytics plugin');
|
|
}
|
|
postInit(err) {
|
|
this.log.debug('postInit !!');
|
|
if (err) {
|
|
this.log.error(err);
|
|
this.initDoneCallback(err);
|
|
return;
|
|
}
|
|
this.log.debug('initting alalytics');
|
|
this.initAnalyticsContext();
|
|
this.log.info('Jibo is ready... awaiting launch command.');
|
|
jibo.face.views.changeView({ removeAll: true, leaveEmpty: true }, () => {
|
|
this.selectFirstSkill(this.launchFirstSkill.bind(this));
|
|
});
|
|
}
|
|
selectFirstSkill(callback) {
|
|
const kbm = jibo.kb.createModel('/skills-config');
|
|
kbm.loadRoot((loadRootErr, rootNode) => {
|
|
if (loadRootErr) {
|
|
this.log.warn("error loading /skills-config root", loadRootErr);
|
|
}
|
|
jibo.secureTransferService.hasBackupData((backupErr, hasBackupData) => {
|
|
if (backupErr) {
|
|
this.log.warn("error when checking if backup data exists", backupErr);
|
|
}
|
|
jibo.errors.getCurrentErrorId((err, currentErrorId) => {
|
|
if (err) {
|
|
this.log.warn("error when checking for current error id", err);
|
|
}
|
|
let nextSkill = this.idle;
|
|
let nextSkillLaunchOptions = {};
|
|
let firstTime = false;
|
|
if (!loadRootErr) {
|
|
firstTime = !rootNode.data.hasAlreadyLaunchedFirstContact;
|
|
}
|
|
else {
|
|
this.log.info(`error reading the hasAlreadyLaunchedFirstContact property from the KB. assuming first time is false`);
|
|
}
|
|
this.log.info(`selectFirstSkill parameter readout: Skills config load error: ${loadRootErr}, first time: ${firstTime}, has backup data: ${hasBackupData}, skip restore: ${this.packageInfo.jibo.debug.skipRestore}, current error id: ${currentErrorId}`);
|
|
if (currentErrorId) {
|
|
nextSkill = this.skills['@be/settings'];
|
|
nextSkillLaunchOptions = { nlu: { entities: { errorId: currentErrorId } } };
|
|
}
|
|
else if (firstTime) {
|
|
if (backupErr && !this.packageInfo.jibo.debug.skipRestore) {
|
|
setTimeout(this.selectFirstSkill.bind(this, callback), 2000);
|
|
return;
|
|
}
|
|
else if (hasBackupData && !this.packageInfo.jibo.debug.skipRestore) {
|
|
nextSkill = this.restoreSkill;
|
|
}
|
|
else {
|
|
nextSkill = this.firstSkill;
|
|
}
|
|
}
|
|
callback(nextSkill, nextSkillLaunchOptions, currentErrorId, firstTime);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
launchFirstSkill(firstSkill, firstSkillLaunchOptions, firstErrorId, firstTime) {
|
|
this.log.debug('launching first skill');
|
|
const firstSkillHasOpened = () => {
|
|
if (firstErrorId) {
|
|
document.getElementById('splash').style.display = 'none';
|
|
}
|
|
else {
|
|
document.getElementById('splash').remove();
|
|
this.enableSkillSwitching();
|
|
}
|
|
this.initDoneCallback();
|
|
};
|
|
let firstSkillRedirectToken = this.redirect(new SkillSwitchData_1.default(firstSkill, firstSkillLaunchOptions));
|
|
firstSkillRedirectToken.onState(SkillLifecycleState_1.default.SKILL_OPENED, firstSkillHasOpened);
|
|
if (firstErrorId) {
|
|
const onErrorResolved = () => {
|
|
if (firstTime) {
|
|
document.getElementById('splash').style.display = 'block';
|
|
}
|
|
this.selectFirstSkill((nextSkill, nextSkillLaunchOptions, currentErrorId) => {
|
|
let nextSkillRedirectToken = this.redirect(new SkillSwitchData_1.default(nextSkill, nextSkillLaunchOptions));
|
|
if (currentErrorId) {
|
|
nextSkillRedirectToken.onState(SkillLifecycleState_1.default.LIFECYCLE_ENDED, onErrorResolved);
|
|
nextSkillRedirectToken.onState(SkillLifecycleState_1.default.SKILL_OPENED, () => {
|
|
document.getElementById('splash').style.display = 'none';
|
|
});
|
|
}
|
|
else {
|
|
nextSkillRedirectToken.onState(SkillLifecycleState_1.default.SKILL_OPENED, () => {
|
|
document.getElementById('splash').remove();
|
|
this.enableSkillSwitching();
|
|
});
|
|
}
|
|
});
|
|
};
|
|
firstSkillRedirectToken.onState(SkillLifecycleState_1.default.LIFECYCLE_ENDED, onErrorResolved);
|
|
}
|
|
}
|
|
enableSkillSwitching() {
|
|
jibo.globalEvents.skillRelaunch.on(data => {
|
|
const skillName = data.match.skillID;
|
|
this.redirect(new SkillSwitchData_1.default(this.skills[skillName], data));
|
|
});
|
|
jibo.action.setSkillSwitchHandler((skillName, skillData) => {
|
|
return new Promise((resolve) => {
|
|
const skill = this.skills[skillName];
|
|
let redirectToken = this.redirect(new SkillSwitchData_1.default(skill, skillData));
|
|
let resolved = false;
|
|
redirectToken.onState(SkillLifecycleState_1.default.SKILL_OPENED, () => {
|
|
resolved = true;
|
|
resolve(jibo.action.types.Status.SUCCEEDED);
|
|
});
|
|
redirectToken.onState(SkillLifecycleState_1.default.LIFECYCLE_ENDED, () => {
|
|
if (!resolved) {
|
|
this.log.warn(`Skill lifecycle ended before skill was opened: ${redirectToken.skillLifecycleEndState}`);
|
|
}
|
|
resolved = true;
|
|
resolve(jibo.action.types.Status.FAILED);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
get currentSkill() {
|
|
return this._skillSwitchScheduler.currentSkillRedirectToken ? this._skillSwitchScheduler.currentSkillRedirectToken.skillSwitchData.skill : null;
|
|
}
|
|
exit(exitingSkill, exitOptions = {}, done = () => { }) {
|
|
const skipEoS = !!(exitOptions.noElementsOfSurprise || exitOptions.globalNoMatch);
|
|
const currentSkill = this._skillSwitchScheduler.currentSkillRedirectToken ? this._skillSwitchScheduler.currentSkillRedirectToken.skillSwitchData.skill : null;
|
|
if (exitingSkill !== currentSkill) {
|
|
this.log.warn(`Trying to call Be#exit from non-current skill ${exitingSkill}. Current skill is ${currentSkill}`);
|
|
return;
|
|
}
|
|
if (!skipEoS &&
|
|
currentSkill !== this.idle &&
|
|
currentSkill !== this.eosSkill &&
|
|
!currentSkill.isElementOfSurprise &&
|
|
!currentSkill.skipSurprisesExternal) {
|
|
let redirectToken = this.redirect(new SkillSwitchData_1.default(this.eosSkill, { lastSkill: currentSkill.assetPack }));
|
|
redirectToken.addOnSkillLifecycleEnd(done);
|
|
}
|
|
else {
|
|
let redirectToken = this.redirect(new SkillSwitchData_1.default(this.idle, { exitOptions }));
|
|
redirectToken.addOnSkillLifecycleEnd(done);
|
|
}
|
|
}
|
|
skillRedirect(redirectingSkill, name, options) {
|
|
const skill = this.skills[name];
|
|
const currentSkill = this._skillSwitchScheduler.currentSkillRedirectToken ? this._skillSwitchScheduler.currentSkillRedirectToken.skillSwitchData.skill : null;
|
|
if (redirectingSkill !== currentSkill) {
|
|
this.log.warn(`Trying to call Be#redirect from non-current skill ${redirectingSkill}. Current skill is ${currentSkill}`);
|
|
return;
|
|
}
|
|
if (skill) {
|
|
this.log.info("REDIRECT: skill redirect: ", name, options);
|
|
this.redirect(new SkillSwitchData_1.default(skill, options));
|
|
}
|
|
else {
|
|
this.log.error("REDIRECT: skill redirect failed. cannot find skill: ", name, options);
|
|
}
|
|
}
|
|
redirect(skillSwitchData) {
|
|
return this._skillSwitchScheduler.requestSkillRedirect(skillSwitchData);
|
|
}
|
|
destroy(callback) {
|
|
if (document.getElementById('splash')) {
|
|
document.getElementById('splash').remove();
|
|
}
|
|
jibo.globalEvents.skillRelaunch.removeAllListeners();
|
|
this._skillSwitchScheduler.destroy()
|
|
.then(() => {
|
|
let destroySkillPromises = [];
|
|
Object.keys(this.skills).forEach((skillId) => {
|
|
let destroySkillPromise = new Promise((resolve, reject) => {
|
|
try {
|
|
this.skills[skillId].destroy((err) => {
|
|
jibo.loader.deleteCache(skillId);
|
|
if (err) {
|
|
reject(err);
|
|
}
|
|
else {
|
|
resolve();
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
reject(err);
|
|
}
|
|
});
|
|
destroySkillPromises.push(destroySkillPromise);
|
|
});
|
|
return Promise.all(destroySkillPromises);
|
|
})
|
|
.catch((err) => {
|
|
this.log.error(err);
|
|
})
|
|
.then(() => {
|
|
callback();
|
|
});
|
|
}
|
|
_validateSkill(skill) {
|
|
let valid = true;
|
|
const proto = Object.getPrototypeOf(skill);
|
|
if (proto.hasOwnProperty('refresh')) {
|
|
valid = false;
|
|
this.log.debug(skill.assetPack, " CANNOT override 'refresh'.");
|
|
}
|
|
if (proto.hasOwnProperty('redirect')) {
|
|
valid = false;
|
|
this.log.debug(skill.assetPack, " CANNOT override 'redirect'.");
|
|
}
|
|
if (!proto.hasOwnProperty('open')) {
|
|
valid = false;
|
|
this.log.debug(skill.assetPack, " MUST override 'open'.");
|
|
}
|
|
if (!proto.hasOwnProperty('close')) {
|
|
valid = false;
|
|
this.log.debug(skill.assetPack, " MUST override 'close'.");
|
|
}
|
|
return valid;
|
|
}
|
|
}
|
|
Be.BeSkill = be_framework_1.BeSkill;
|
|
Be.LibraryAnalytics = LibraryAnalytics_1.default;
|
|
Be.SkillSwitchScheduler = SkillSwitchScheduler_1.default;
|
|
Be.SkillSwitchUtil = SkillSwitchUtil_1.default;
|
|
Be.SkillRedirectToken = SkillRedirectToken_1.default;
|
|
Be.SkillLifecycle = SkillLifecycle_1.default;
|
|
Be.SkillSwitchData = SkillSwitchData_1.default;
|
|
Be.SkillLifecycleState = SkillLifecycleState_1.default;
|
|
Be.SkillLifecycleEndState = SkillLifecycleEndState_1.default;
|
|
Be.ModuleVersions = ModuleVersions_1.default;
|
|
Be.jibo = jibo;
|
|
Be.TimerSpy = TimerSpy_1.default;
|
|
Be.DateSetter = DateSetter_1.default;
|
|
exports.default = Be;
|
|
be_framework_1.BeSkill.registerOpenHook((oldSkill, newSkill, result) => {
|
|
return (resolve) => {
|
|
jibo.performance.log('BeSkillOpen', JSON.stringify({ newSkill, oldSkill, result }));
|
|
resolve();
|
|
};
|
|
});
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},"/src")
|
|
|
|
},{"./DateSetter":2,"./LibraryAnalytics":3,"./ModuleVersions":4,"./SkillLifecycle":5,"./SkillLifecycleEndState":6,"./SkillLifecycleState":7,"./SkillRedirectToken":8,"./SkillSwitchData":9,"./SkillSwitchScheduler":10,"./SkillSwitchUtil":11,"./TimerSpy":12,"./log":14,"@be/be-framework":undefined,"jibo":undefined,"jibo-client-framework":undefined,"jibo-log":undefined,"path":undefined,"url":undefined}],2:[function(require,module,exports){
|
|
(function (global){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class DateSetter {
|
|
static shiftDate(year, month, day, hours = 12, minutes = 0, seconds = 0) {
|
|
if (month <= 0) {
|
|
console.warn(`${month} found for month, replacing with 1. Fake dates are indexed by 1 on input for usability.`);
|
|
month = 1;
|
|
}
|
|
if (this._origDate) {
|
|
global.Date = this._origDate;
|
|
}
|
|
const OrigDate = global.Date;
|
|
this._origDate = OrigDate;
|
|
const fakeDateArgs = [year, month - 1, day, hours, minutes, seconds];
|
|
const fakeDate = Reflect.construct(OrigDate, fakeDateArgs);
|
|
const fakeDateStartTime = OrigDate.now();
|
|
global.Date = function () {
|
|
if (arguments.length === 0) {
|
|
const updatedFakeDateMs = fakeDate.getTime() + (OrigDate.now() - fakeDateStartTime);
|
|
return Reflect.construct(OrigDate, [updatedFakeDateMs]);
|
|
}
|
|
else {
|
|
return Reflect.construct(OrigDate, arguments);
|
|
}
|
|
};
|
|
global.Date.prototype = OrigDate.prototype;
|
|
global.Date.now = function () {
|
|
const timeSinceFakeDateStart = (OrigDate.now() - fakeDateStartTime);
|
|
return fakeDate.getTime() + timeSinceFakeDateStart;
|
|
};
|
|
global.Date.parse = OrigDate.parse;
|
|
global.Date.UTC = OrigDate.UTC;
|
|
console.log(`Setting up fake Date of: ${fakeDate.toString()}.`);
|
|
}
|
|
static restoreDate() {
|
|
if (this._origDate) {
|
|
global.Date = this._origDate;
|
|
this._origDate = null;
|
|
console.info(`Date Restored to: ${(new Date()).toString()}.`);
|
|
}
|
|
else {
|
|
console.warn('No fake Date to restore.');
|
|
}
|
|
}
|
|
}
|
|
exports.default = DateSetter;
|
|
|
|
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
|
|
},{}],3:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const be_framework_1 = require("@be/be-framework");
|
|
class LibraryAnalytics {
|
|
get currentSkill() {
|
|
const plugin = be_framework_1.BeSkill.plugins.analytics;
|
|
if (plugin) {
|
|
return plugin.currentSkill;
|
|
}
|
|
return 'none';
|
|
}
|
|
set LOG_TO_CONSOLE(value) {
|
|
const plugin = be_framework_1.BeSkill.plugins.analytics;
|
|
if (plugin && plugin._segmentAnalytics) {
|
|
plugin._segmentAnalytics.LOG_TO_CONSOLE = value;
|
|
}
|
|
}
|
|
track(event, data) {
|
|
const plugin = be_framework_1.BeSkill.plugins.analytics;
|
|
if (plugin) {
|
|
plugin.skillEvent(event, data);
|
|
}
|
|
}
|
|
flush() {
|
|
const plugin = be_framework_1.BeSkill.plugins.analytics;
|
|
if (plugin) {
|
|
plugin.flush();
|
|
}
|
|
}
|
|
}
|
|
exports.default = LibraryAnalytics;
|
|
|
|
},{"@be/be-framework":undefined}],4:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const path = require("path");
|
|
const jibo = require("jibo");
|
|
class ModuleVersions {
|
|
static log(log, beRootDir) {
|
|
const bePackageJson = require(path.resolve(beRootDir, "package.json"));
|
|
let packageInfo = {};
|
|
for (let packageName in bePackageJson.dependencies) {
|
|
try {
|
|
const packageJson = require(path.resolve(beRootDir, "node_modules", packageName, "package.json"));
|
|
packageInfo[packageName] = packageJson.version;
|
|
}
|
|
catch (error) {
|
|
packageInfo[packageName] = "Not Installed? (Hoisted?)";
|
|
}
|
|
}
|
|
if (jibo.runMode !== undefined &&
|
|
jibo.runMode !== jibo.RunMode.UNIT_TESTS) {
|
|
log.info('Skill versions:', packageInfo);
|
|
}
|
|
}
|
|
}
|
|
exports.default = ModuleVersions;
|
|
|
|
},{"jibo":undefined,"path":undefined}],5:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const SkillLifecycleState_1 = require("./SkillLifecycleState");
|
|
const SkillLifecycleEndState_1 = require("./SkillLifecycleEndState");
|
|
const log_1 = require("./log");
|
|
class SkillLifecycle {
|
|
constructor(skillSwitchData) {
|
|
this._skillSwitchData = skillSwitchData;
|
|
this._onSkillLifecycleStateChangeCallbackSet = new Set();
|
|
this._onSkillLifecycleEndCallbackSet = new Set();
|
|
this._prevSkillLifecycleState = null;
|
|
this._setSkillLifecycleState(SkillLifecycleState_1.default.NONE);
|
|
this._skillLifecycleEndState = SkillLifecycleEndState_1.default.NONE;
|
|
this.log = log_1.default.createChild("SkillLifecycle");
|
|
}
|
|
get skillSwitchData() {
|
|
return this._skillSwitchData;
|
|
}
|
|
get skillLifecycleState() {
|
|
return this._skillLifecycleState;
|
|
}
|
|
get skillLifecycleEndState() {
|
|
return this._skillLifecycleEndState;
|
|
}
|
|
addOnSkillLifecycleStateChange(callback) {
|
|
if (this._onSkillLifecycleStateChangeCallbackSet.has(callback)) {
|
|
return false;
|
|
}
|
|
this._onSkillLifecycleStateChangeCallbackSet.add(callback);
|
|
return true;
|
|
}
|
|
addOnSkillLifecycleEnd(callback) {
|
|
let returnValue = false;
|
|
if (!this._onSkillLifecycleEndCallbackSet.has(callback)) {
|
|
this._onSkillLifecycleEndCallbackSet.add(callback);
|
|
returnValue = true;
|
|
}
|
|
if (this._skillLifecycleState === SkillLifecycleState_1.default.LIFECYCLE_ENDED) {
|
|
this._callOnSkillLifecycleEndCallbacks();
|
|
}
|
|
return returnValue;
|
|
}
|
|
skillSwitchRequested() {
|
|
if (this._skillLifecycleState === SkillLifecycleState_1.default.NONE) {
|
|
this._setSkillLifecycleState(SkillLifecycleState_1.default.SKILL_SWITCH_REQUESTED);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
skillSwitchPending() {
|
|
if (this._skillLifecycleState === SkillLifecycleState_1.default.SKILL_SWITCH_REQUESTED) {
|
|
this._setSkillLifecycleState(SkillLifecycleState_1.default.SKILL_SWITCH_PENDING);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
startSkillOpen() {
|
|
if (this._skillLifecycleState === SkillLifecycleState_1.default.SKILL_SWITCH_PENDING) {
|
|
this._setSkillLifecycleState(SkillLifecycleState_1.default.SKILL_START_OPEN);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
skillOpened() {
|
|
if (this._skillLifecycleState === SkillLifecycleState_1.default.SKILL_START_OPEN) {
|
|
this._setSkillLifecycleState(SkillLifecycleState_1.default.SKILL_OPENED);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
skillLifecycleEnded(skillLifecycleEndState) {
|
|
if (this._skillLifecycleState === SkillLifecycleState_1.default.LIFECYCLE_ENDED) {
|
|
return false;
|
|
}
|
|
this._skillLifecycleEndState = skillLifecycleEndState;
|
|
this._setSkillLifecycleState(SkillLifecycleState_1.default.LIFECYCLE_ENDED);
|
|
this._callOnSkillLifecycleEndCallbacks();
|
|
return true;
|
|
}
|
|
_setSkillLifecycleState(skillLifecycleState) {
|
|
this._prevSkillLifecycleState = this._skillLifecycleState;
|
|
this._skillLifecycleState = skillLifecycleState;
|
|
if (this._prevSkillLifecycleState !== this._skillLifecycleState) {
|
|
if (this._onSkillLifecycleStateChangeCallbackSet.size > 0) {
|
|
this._onSkillLifecycleStateChangeCallbackSet.forEach((lifecycleStateChangeCallback) => {
|
|
try {
|
|
lifecycleStateChangeCallback(this._prevSkillLifecycleState, this._skillLifecycleState);
|
|
}
|
|
catch (err) {
|
|
this.log.error("SkillSwitch: caught exception in onSkillLifecycleStateChange callback", err, lifecycleStateChangeCallback);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
_callOnSkillLifecycleEndCallbacks() {
|
|
if (this._onSkillLifecycleEndCallbackSet.size > 0) {
|
|
this._onSkillLifecycleEndCallbackSet.forEach((lifecycleEndCallback) => {
|
|
try {
|
|
lifecycleEndCallback(this._skillLifecycleEndState);
|
|
}
|
|
catch (err) {
|
|
this.log.error("SkillSwitch: caught exception in onSkillLifecycleEnd callback", err);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
exports.default = SkillLifecycle;
|
|
|
|
},{"./SkillLifecycleEndState":6,"./SkillLifecycleState":7,"./log":14}],6:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var SkillLifecycleEndState;
|
|
(function (SkillLifecycleEndState) {
|
|
SkillLifecycleEndState[SkillLifecycleEndState["NONE"] = 0] = "NONE";
|
|
SkillLifecycleEndState[SkillLifecycleEndState["PENDING_SKILL_SWITCH_INTERRUPTED"] = 1] = "PENDING_SKILL_SWITCH_INTERRUPTED";
|
|
SkillLifecycleEndState[SkillLifecycleEndState["SKILL_SWITCH_REQUEST_DENIED"] = 2] = "SKILL_SWITCH_REQUEST_DENIED";
|
|
SkillLifecycleEndState[SkillLifecycleEndState["SKILL_REFRESH_FAILED"] = 3] = "SKILL_REFRESH_FAILED";
|
|
SkillLifecycleEndState[SkillLifecycleEndState["SKILL_OPEN_FAILED"] = 4] = "SKILL_OPEN_FAILED";
|
|
SkillLifecycleEndState[SkillLifecycleEndState["SKILL_CLOSE_FAILED"] = 5] = "SKILL_CLOSE_FAILED";
|
|
SkillLifecycleEndState[SkillLifecycleEndState["SKILL_EXITED"] = 6] = "SKILL_EXITED";
|
|
SkillLifecycleEndState[SkillLifecycleEndState["SKILL_REFRESHED"] = 7] = "SKILL_REFRESHED";
|
|
})(SkillLifecycleEndState || (SkillLifecycleEndState = {}));
|
|
;
|
|
exports.default = SkillLifecycleEndState;
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var SkillLifecycleState;
|
|
(function (SkillLifecycleState) {
|
|
SkillLifecycleState[SkillLifecycleState["NONE"] = 0] = "NONE";
|
|
SkillLifecycleState[SkillLifecycleState["SKILL_SWITCH_REQUESTED"] = 1] = "SKILL_SWITCH_REQUESTED";
|
|
SkillLifecycleState[SkillLifecycleState["SKILL_SWITCH_PENDING"] = 2] = "SKILL_SWITCH_PENDING";
|
|
SkillLifecycleState[SkillLifecycleState["SKILL_START_OPEN"] = 4] = "SKILL_START_OPEN";
|
|
SkillLifecycleState[SkillLifecycleState["SKILL_OPENED"] = 5] = "SKILL_OPENED";
|
|
SkillLifecycleState[SkillLifecycleState["LIFECYCLE_ENDED"] = 6] = "LIFECYCLE_ENDED";
|
|
})(SkillLifecycleState || (SkillLifecycleState = {}));
|
|
;
|
|
exports.default = SkillLifecycleState;
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class SkillRedirectToken {
|
|
constructor(skillLifecycle, skillSwitchData) {
|
|
this._skillLifecycle = skillLifecycle;
|
|
this._skillSwitchData = skillSwitchData;
|
|
}
|
|
get skillLifecycleState() {
|
|
return this._skillLifecycle.skillLifecycleState;
|
|
}
|
|
get skillLifecycleEndState() {
|
|
return this._skillLifecycle.skillLifecycleEndState;
|
|
}
|
|
get skillSwitchData() {
|
|
return this._skillSwitchData;
|
|
}
|
|
addOnSkillLifecycleStateChange(callback) {
|
|
this._skillLifecycle.addOnSkillLifecycleStateChange((prevLifecycleState, currentLifecycleState) => {
|
|
callback(prevLifecycleState, currentLifecycleState);
|
|
});
|
|
}
|
|
addOnSkillLifecycleEnd(callback) {
|
|
this._skillLifecycle.addOnSkillLifecycleEnd((skillLifecycleEndState) => {
|
|
callback(skillLifecycleEndState);
|
|
});
|
|
}
|
|
onState(lifecycleState, callback) {
|
|
if (this._skillLifecycle.skillLifecycleState >= lifecycleState) {
|
|
callback();
|
|
}
|
|
else {
|
|
this._skillLifecycle.addOnSkillLifecycleStateChange((prevLifecycleState, currentLifecycleState) => {
|
|
if (lifecycleState === currentLifecycleState) {
|
|
callback();
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
exports.default = SkillRedirectToken;
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
class SkillSwitchData {
|
|
constructor(skill, options) {
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
if (!options.asr) {
|
|
options.asr = { text: '', confidence: 1 };
|
|
}
|
|
if (options.nlu && !options.nlu.entities) {
|
|
options.nlu.entities = {};
|
|
}
|
|
this._skill = skill;
|
|
this._options = options;
|
|
}
|
|
get skill() {
|
|
return this._skill;
|
|
}
|
|
get name() {
|
|
return this._skill.assetPack;
|
|
}
|
|
get options() {
|
|
return this._options;
|
|
}
|
|
get priority() {
|
|
if (this.name === "@be/restore") {
|
|
return 5;
|
|
}
|
|
else if (this._options.nlu && this.name === "@be/settings") {
|
|
if (this._options.nlu.intent === "wipe") {
|
|
return 4;
|
|
}
|
|
else if (this._options.nlu.entities.errorId) {
|
|
return 3;
|
|
}
|
|
}
|
|
else if (this.name === "@be/tutorial" || this.name === "@be/first-contact") {
|
|
return 2;
|
|
}
|
|
else if (this._options.nlu && this.name === "@be/clock" && this._options.nlu.intent === "finished" &&
|
|
((this._options.nlu.entities.domain === "alarm") || (this._options.nlu.entities.domain === "timer"))) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
exports.default = SkillSwitchData;
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo = require("jibo");
|
|
const SkillLifecycle_1 = require("./SkillLifecycle");
|
|
const SkillSwitchUtil_1 = require("./SkillSwitchUtil");
|
|
const SkillLifecycleEndState_1 = require("./SkillLifecycleEndState");
|
|
const SkillRedirectToken_1 = require("./SkillRedirectToken");
|
|
const SkillSwitchData_1 = require("./SkillSwitchData");
|
|
const TimerSpy_1 = require("./TimerSpy");
|
|
const log_1 = require("./log");
|
|
class SkillSwitchScheduler {
|
|
constructor(idleSkill) {
|
|
this._idleSkill = idleSkill;
|
|
this._currentSkillLifecycle = null;
|
|
this._currentSkillRedirectToken = null;
|
|
this._pendingSkillLifecycle = null;
|
|
this._pendingSkillRedirectToken = null;
|
|
this._updateTimeout = null;
|
|
this._updateMethod = this._update.bind(this);
|
|
this._updateMethod.isGlobalTimer = true;
|
|
this.log = log_1.default.createChild("SkillSwitchScheduler");
|
|
this._destroyed = false;
|
|
}
|
|
run() {
|
|
this._updateMethod();
|
|
}
|
|
get currentSkillRedirectToken() {
|
|
return this._currentSkillRedirectToken;
|
|
}
|
|
requestSkillRedirect(requestedSkillSwitchData) {
|
|
const requestedSkillName = requestedSkillSwitchData.name;
|
|
const requestedSkillOptions = requestedSkillSwitchData.options;
|
|
this.log.info("requested skill switch", requestedSkillName, requestedSkillOptions);
|
|
let reqestedSkillLifecycle = new SkillLifecycle_1.default(requestedSkillSwitchData);
|
|
let skillRedirectToken = new SkillRedirectToken_1.default(reqestedSkillLifecycle, requestedSkillSwitchData);
|
|
reqestedSkillLifecycle.skillSwitchRequested();
|
|
if (!this._pendingSkillLifecycle && !this._currentSkillLifecycle) {
|
|
this.log.info("no current or pending skill. launching into requested skill");
|
|
this._pendingSkillLifecycle = reqestedSkillLifecycle;
|
|
this._pendingSkillLifecycle.skillSwitchPending();
|
|
this._pendingSkillRedirectToken = skillRedirectToken;
|
|
}
|
|
else if (this._currentSkillLifecycle && !this._pendingSkillLifecycle) {
|
|
if (SkillSwitchUtil_1.default.canSkillSwitch(this._currentSkillLifecycle.skillSwitchData, reqestedSkillLifecycle.skillSwitchData)) {
|
|
this.log.info("no pending skill. interrupting current skill");
|
|
this._pendingSkillLifecycle = reqestedSkillLifecycle;
|
|
this._pendingSkillLifecycle.skillSwitchPending();
|
|
this._pendingSkillRedirectToken = skillRedirectToken;
|
|
}
|
|
else {
|
|
this.log.info("no pending skill. cannot interrupt current skill. denying skill switch request");
|
|
reqestedSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_SWITCH_REQUEST_DENIED);
|
|
}
|
|
}
|
|
else if (!this._currentSkillLifecycle && this._pendingSkillLifecycle) {
|
|
if (reqestedSkillLifecycle.skillSwitchData.priority >= this._pendingSkillLifecycle.skillSwitchData.priority) {
|
|
this.log.info("no current skill. requested skill is >= to pending skill priority. switching into requested skill");
|
|
this._pendingSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.PENDING_SKILL_SWITCH_INTERRUPTED);
|
|
this._pendingSkillLifecycle = reqestedSkillLifecycle;
|
|
this._pendingSkillRedirectToken = skillRedirectToken;
|
|
this._pendingSkillLifecycle.skillSwitchPending();
|
|
}
|
|
else {
|
|
this.log.info("no current skill. requested skill is < to pending skill priority. denying skill switch request");
|
|
reqestedSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_SWITCH_REQUEST_DENIED);
|
|
}
|
|
}
|
|
else {
|
|
if (reqestedSkillLifecycle.skillSwitchData.priority >= this._pendingSkillLifecycle.skillSwitchData.priority &&
|
|
SkillSwitchUtil_1.default.canSkillSwitch(this._currentSkillLifecycle.skillSwitchData, reqestedSkillLifecycle.skillSwitchData)) {
|
|
this.log.info("current skill and pending skill exist. requested skill is >= priority to pending skill and we can switch from current skill");
|
|
this._pendingSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.PENDING_SKILL_SWITCH_INTERRUPTED);
|
|
this._pendingSkillLifecycle = reqestedSkillLifecycle;
|
|
this._pendingSkillRedirectToken = skillRedirectToken;
|
|
this._pendingSkillLifecycle.skillSwitchPending();
|
|
}
|
|
else {
|
|
this.log.info("current skill and pending skill exist. requested skill switch is either < priority than pending skill or cannot switch into current skill. denying skill switch request");
|
|
reqestedSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_SWITCH_REQUEST_DENIED);
|
|
}
|
|
}
|
|
return skillRedirectToken;
|
|
}
|
|
_update() {
|
|
if (!this._pendingSkillLifecycle) {
|
|
this._recallUpdate();
|
|
return;
|
|
}
|
|
let currentSkillName = this._currentSkillLifecycle ? this._currentSkillLifecycle.skillSwitchData.name : null;
|
|
let currentSkillOptions = this._currentSkillLifecycle ? this._currentSkillLifecycle.skillSwitchData.options : null;
|
|
let pendingSkillName = this._pendingSkillLifecycle ? this._pendingSkillLifecycle.skillSwitchData.name : null;
|
|
let pendingSkillOptions = this._pendingSkillLifecycle ? this._pendingSkillLifecycle.skillSwitchData.options : null;
|
|
this.log.info('switching skill', currentSkillName, this._pendingSkillLifecycle.skillSwitchData.name);
|
|
if (this._currentSkillLifecycle && this._currentSkillLifecycle.skillSwitchData.skill === this._pendingSkillLifecycle.skillSwitchData.skill) {
|
|
try {
|
|
this.log.info('refreshing skill', currentSkillName, currentSkillOptions, pendingSkillOptions);
|
|
this._pendingSkillLifecycle.startSkillOpen();
|
|
this._pendingSkillLifecycle.skillSwitchData.skill.open(this._pendingSkillLifecycle.skillSwitchData.options, true, currentSkillName, this._currentSkillLifecycle.skillSwitchData.options);
|
|
this.log.info('refreshing skill success', currentSkillName, currentSkillOptions, pendingSkillOptions);
|
|
this._currentSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_REFRESHED);
|
|
this._currentSkillRedirectToken = this._pendingSkillRedirectToken;
|
|
this._currentSkillLifecycle = this._pendingSkillLifecycle;
|
|
this._pendingSkillLifecycle = null;
|
|
this._pendingSkillRedirectToken = null;
|
|
this._currentSkillLifecycle.skillOpened();
|
|
}
|
|
catch (err) {
|
|
this._currentSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_REFRESH_FAILED);
|
|
this._pendingSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_REFRESH_FAILED);
|
|
this._pendingSkillLifecycle = null;
|
|
this._pendingSkillRedirectToken = null;
|
|
this.log.error('refresh skill failed', currentSkillName, currentSkillOptions, err);
|
|
this.requestSkillRedirect(new SkillSwitchData_1.default(this._idleSkill, {}));
|
|
}
|
|
finally {
|
|
this._recallUpdate();
|
|
}
|
|
}
|
|
else {
|
|
this.log.info('starting close skill', currentSkillName);
|
|
const skillToClose = this._currentSkillLifecycle ? this._currentSkillLifecycle.skillSwitchData.skill : null;
|
|
Promise.resolve()
|
|
.then(() => {
|
|
return SkillSwitchUtil_1.default.closeSkill(skillToClose, pendingSkillName);
|
|
})
|
|
.then(() => {
|
|
this.log.info('ending close skill', currentSkillName);
|
|
if (this._currentSkillLifecycle) {
|
|
this._currentSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_EXITED);
|
|
}
|
|
this.log.info('deferring to action system with pending skill:', pendingSkillName, pendingSkillOptions);
|
|
return Promise.resolve()
|
|
.then(() => {
|
|
return this._completeAction();
|
|
})
|
|
.then((pendingSkillLifecycle) => {
|
|
if (this._pendingSkillLifecycle !== pendingSkillLifecycle) {
|
|
this.log.info('the pending skill lifecycle which the action system has completed with is not the same as the current pending skill lifecycle', pendingSkillLifecycle.skillSwitchData.name, pendingSkillLifecycle.skillSwitchData.options, this._pendingSkillLifecycle.skillSwitchData.name, this._pendingSkillLifecycle.skillSwitchData.options);
|
|
}
|
|
}, (err) => {
|
|
this.log.warn('action system completed with error. Continuing with skill switching', err);
|
|
})
|
|
.then(() => {
|
|
pendingSkillName = this._pendingSkillLifecycle ? this._pendingSkillLifecycle.skillSwitchData.name : null;
|
|
pendingSkillOptions = this._pendingSkillLifecycle ? this._pendingSkillLifecycle.skillSwitchData.options : null;
|
|
this.log.info('starting skill open', pendingSkillName, pendingSkillOptions);
|
|
let prevSkillLifecycle = this._currentSkillLifecycle;
|
|
this._currentSkillLifecycle = this._pendingSkillLifecycle;
|
|
this._currentSkillRedirectToken = this._pendingSkillRedirectToken;
|
|
currentSkillName = this._currentSkillLifecycle ? this._currentSkillLifecycle.skillSwitchData.name : null;
|
|
currentSkillOptions = this._currentSkillLifecycle ? this._currentSkillLifecycle.skillSwitchData.options : null;
|
|
this._pendingSkillLifecycle = null;
|
|
this._pendingSkillRedirectToken = null;
|
|
pendingSkillName = null;
|
|
pendingSkillOptions = null;
|
|
TimerSpy_1.default.instance.getCurrentSkillNameCallback = () => {
|
|
return this._currentSkillLifecycle.skillSwitchData.skill.assetPack;
|
|
};
|
|
this._currentSkillLifecycle.startSkillOpen();
|
|
return Promise.resolve()
|
|
.then(() => {
|
|
return SkillSwitchUtil_1.default.openNewSkill(prevSkillLifecycle, this._currentSkillLifecycle);
|
|
})
|
|
.then(() => {
|
|
this._currentSkillLifecycle.skillOpened();
|
|
this.log.info('skill open success', currentSkillName, currentSkillOptions);
|
|
}, (err) => {
|
|
this.log.error('skill open failed', currentSkillName, currentSkillOptions, err);
|
|
this.requestSkillRedirect(new SkillSwitchData_1.default(this._idleSkill, {}));
|
|
this._currentSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_OPEN_FAILED);
|
|
});
|
|
});
|
|
}, (err) => {
|
|
if (this._currentSkillLifecycle) {
|
|
this._currentSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_CLOSE_FAILED);
|
|
this.log.error('error closing skill', currentSkillName, currentSkillOptions, err);
|
|
}
|
|
else if (this._pendingSkillLifecycle) {
|
|
this._pendingSkillLifecycle.skillLifecycleEnded(SkillLifecycleEndState_1.default.SKILL_OPEN_FAILED);
|
|
this.log.error('error closing skill', pendingSkillName, pendingSkillOptions, err);
|
|
}
|
|
else {
|
|
this.log.error('error closing skill', err);
|
|
}
|
|
})
|
|
.then(() => {
|
|
this._recallUpdate();
|
|
});
|
|
}
|
|
}
|
|
_recallUpdate() {
|
|
if (this._updateTimeout) {
|
|
jibo.timer.clearTimeout(this._updateTimeout);
|
|
this._updateTimeout = null;
|
|
}
|
|
if (!this._destroyed) {
|
|
this._updateTimeout = jibo.timer.setTimeout(this._updateMethod, 10);
|
|
}
|
|
}
|
|
_completeAction() {
|
|
return new Promise((resolve, reject) => {
|
|
let currentPendingSkillLifecycle = null;
|
|
let goal = null;
|
|
let actionSystemGoalInterval = jibo.timer.setInterval(() => {
|
|
if (currentPendingSkillLifecycle !== this._pendingSkillLifecycle) {
|
|
currentPendingSkillLifecycle = this._pendingSkillLifecycle;
|
|
if (goal) {
|
|
goal.events.finished.removeAllListeners();
|
|
}
|
|
goal = jibo.action.addBeSkillSwitchGoal({
|
|
skillName: currentPendingSkillLifecycle.skillSwitchData.name,
|
|
skillOptions: currentPendingSkillLifecycle.skillSwitchData.options,
|
|
beSkillPriority: currentPendingSkillLifecycle.skillSwitchData.priority,
|
|
beSkillPreferences: {
|
|
cancelOrientOnStart: false
|
|
}
|
|
});
|
|
this.log.info("waiting on action system", currentPendingSkillLifecycle.skillSwitchData.name);
|
|
goal.events.finished.on((status) => {
|
|
actionSystemGoalInterval.destroy();
|
|
if (status === jibo.action.types.GoalFinishedStatus.SUCCEEDED) {
|
|
this.log.info("action system reported accomplished goal", currentPendingSkillLifecycle.skillSwitchData.name);
|
|
return resolve(currentPendingSkillLifecycle);
|
|
}
|
|
else {
|
|
return reject(new Error(`action system failed to meet goal '${currentPendingSkillLifecycle.skillSwitchData.name}' with status: ${status}`));
|
|
}
|
|
});
|
|
}
|
|
}, 10);
|
|
});
|
|
}
|
|
destroy() {
|
|
this._destroyed = true;
|
|
return Promise.resolve()
|
|
.then(() => {
|
|
if (this._updateTimeout) {
|
|
jibo.timer.clearTimeout(this._updateTimeout);
|
|
this._updateTimeout = null;
|
|
}
|
|
if (this._currentSkillRedirectToken) {
|
|
return SkillSwitchUtil_1.default.closeSkill(this._currentSkillLifecycle.skillSwitchData.skill);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
exports.default = SkillSwitchScheduler;
|
|
|
|
},{"./SkillLifecycle":5,"./SkillLifecycleEndState":6,"./SkillRedirectToken":8,"./SkillSwitchData":9,"./SkillSwitchUtil":11,"./TimerSpy":12,"./log":14,"jibo":undefined}],11:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo = require("jibo");
|
|
const path = require("path");
|
|
const be_framework_1 = require("@be/be-framework");
|
|
const TimerSpy_1 = require("./TimerSpy");
|
|
const log_1 = require("./log");
|
|
const log = log_1.default.createChild("SkillSwitchUtil");
|
|
const packageInfo = require(path.join(jibo.utils.PathUtils.findRoot(), 'package.json'));
|
|
const closeSkillTimeoutMS = 5000;
|
|
const openSkillTimeoutMS = 5000;
|
|
class SkillSwitchUtil {
|
|
static canSkillSwitch(currentSkillSwitchData, newSkillSwitchData) {
|
|
if (currentSkillSwitchData.priority > newSkillSwitchData.priority) {
|
|
return currentSkillSwitchData.skill.isInterruptible;
|
|
}
|
|
else {
|
|
return true;
|
|
}
|
|
}
|
|
static closeSkill(skill, pendingSkillName) {
|
|
let closeTimeout = null;
|
|
return new Promise((resolve, reject) => {
|
|
closeTimeout = setTimeout(() => {
|
|
return reject('skill took too long to close. Force closing.');
|
|
}, closeSkillTimeoutMS);
|
|
if (skill) {
|
|
try {
|
|
log.info("stopping " + skill.assetPack);
|
|
skill.skipSurprisesExternal = false;
|
|
skill.close(resolve, pendingSkillName);
|
|
}
|
|
catch (err) {
|
|
log.error(err);
|
|
return reject(err);
|
|
}
|
|
}
|
|
else {
|
|
return resolve();
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
return err;
|
|
})
|
|
.then((err) => {
|
|
clearTimeout(closeTimeout);
|
|
if (err) {
|
|
log.error(`Skill closing failed: ${err}. Cleaning up cache anyway.`);
|
|
jibo.face.reset();
|
|
jibo.loader.assetManager.cancelAll();
|
|
}
|
|
if (skill) {
|
|
if (jibo.loader.activeCache !== skill.assetPack) {
|
|
log.error(`While closing skill ${skill.assetPack}, expected active cache to be ${skill.assetPack} but is ${jibo.loader.activeCache}. Something may have changed the default / active cache while the skill was closing.`);
|
|
}
|
|
if (!packageInfo.jibo.debug.noCacheDestroy) {
|
|
jibo.loader.deleteCache(skill.assetPack);
|
|
}
|
|
jibo.expression.destroyCaches(skill.assetPack);
|
|
}
|
|
jibo.loader.activeCache = null;
|
|
jibo.embodied.speech.setPaths(null);
|
|
if (packageInfo.jibo.debug.resourceLeak && skill) {
|
|
TimerSpy_1.default.instance.checkSkillCleanup();
|
|
}
|
|
be_framework_1.BeSkill.plugins.analytics.skillExit(pendingSkillName);
|
|
});
|
|
}
|
|
static openNewSkill(currentSkillLifecycle, newSkillLifecycle) {
|
|
const newSkillName = newSkillLifecycle.skillSwitchData.name;
|
|
const newSkillOptions = newSkillLifecycle.skillSwitchData.options;
|
|
let openTimeout = null;
|
|
let oldSkillName = null;
|
|
return new Promise((resolve, reject) => {
|
|
openTimeout = setTimeout(() => {
|
|
return reject('skill took too long to open. Force closing.');
|
|
}, openSkillTimeoutMS);
|
|
oldSkillName = currentSkillLifecycle ? currentSkillLifecycle.skillSwitchData.skill.assetPack : '';
|
|
jibo.loader.basePath = newSkillLifecycle.skillSwitchData.skill.rootPath;
|
|
jibo.sound.basePath = newSkillLifecycle.skillSwitchData.skill.rootPath;
|
|
jibo.loader.addCache(newSkillLifecycle.skillSwitchData.skill.assetPack);
|
|
jibo.loader.activeCache = newSkillLifecycle.skillSwitchData.skill.assetPack;
|
|
jibo.embodied.speech.setPaths(newSkillLifecycle.skillSwitchData.skill.assetPack);
|
|
if (newSkillOptions && newSkillOptions.asr.text) {
|
|
jibo.mim.silentMenus = false;
|
|
}
|
|
try {
|
|
log.info("BeSkill open", oldSkillName, newSkillName, newSkillOptions);
|
|
be_framework_1.BeSkill.open(oldSkillName, newSkillLifecycle.skillSwitchData.skill.assetPack, newSkillOptions, (err) => {
|
|
try {
|
|
if (err) {
|
|
log.error(err);
|
|
}
|
|
log.info("new skill preload", newSkillName);
|
|
newSkillLifecycle.skillSwitchData.skill.preload((err) => {
|
|
return resolve(err);
|
|
});
|
|
}
|
|
catch (err) {
|
|
return reject(err);
|
|
}
|
|
});
|
|
}
|
|
catch (err) {
|
|
return reject(err);
|
|
}
|
|
})
|
|
.catch((err) => {
|
|
return err;
|
|
})
|
|
.then((err) => {
|
|
clearTimeout(openTimeout);
|
|
return new Promise((resolve, reject) => {
|
|
if (err) {
|
|
return reject(err);
|
|
}
|
|
try {
|
|
log.info("opening new skill", newSkillName);
|
|
be_framework_1.BeSkill.plugins.analytics.skillEntry(newSkillName, newSkillOptions, oldSkillName);
|
|
let currentSkillName = currentSkillLifecycle ? currentSkillLifecycle.skillSwitchData.name : null;
|
|
let currentSkillOptions = currentSkillLifecycle ? currentSkillLifecycle.skillSwitchData.options : null;
|
|
newSkillLifecycle.skillSwitchData.skill.skipSurprisesExternal = newSkillOptions && newSkillOptions.match && newSkillOptions.match.skipSurprises;
|
|
newSkillLifecycle.skillSwitchData.skill.open(newSkillOptions, false, currentSkillName, currentSkillOptions);
|
|
return resolve(newSkillLifecycle.skillSwitchData);
|
|
}
|
|
catch (err) {
|
|
return reject(err);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
}
|
|
SkillSwitchUtil.log = log;
|
|
exports.default = SkillSwitchUtil;
|
|
|
|
},{"./TimerSpy":12,"./log":14,"@be/be-framework":undefined,"jibo":undefined,"path":undefined}],12:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo = require("jibo");
|
|
const log_1 = require("./log");
|
|
const log = log_1.default.createChild("TimerSpy");
|
|
class TimerSpy {
|
|
static get instance() {
|
|
if (!TimerSpy._instance) {
|
|
TimerSpy._instance = new TimerSpy();
|
|
}
|
|
return TimerSpy._instance;
|
|
}
|
|
constructor() {
|
|
this.log = log;
|
|
this._globalTimerSymbol = Symbol("global");
|
|
this._initRan = false;
|
|
}
|
|
set getCurrentSkillNameCallback(value) {
|
|
this._getCurrentSkillNameCallback = value;
|
|
}
|
|
init(getCurrentSkillNameCallback) {
|
|
this._initRan = true;
|
|
this._getCurrentSkillNameCallback = getCurrentSkillNameCallback;
|
|
this._skillTimers = {};
|
|
this._originalOn = jibo.timer.on.bind(jibo.timer);
|
|
this._originalRemoveListener = jibo.timer.removeListener.bind(jibo.timer);
|
|
this._originalSetTimeout = jibo.timer.setTimeout.bind(jibo.timer);
|
|
this._originalClearTimeout = jibo.timer.clearTimeout.bind(jibo.timer);
|
|
this._originalSetInterval = jibo.timer.setInterval.bind(jibo.timer);
|
|
this._originalClearInterval = jibo.timer.clearInterval.bind(jibo.timer);
|
|
jibo.timer.on = this.onOverride.bind(this);
|
|
jibo.timer.off = jibo.timer.removeListener = this.removeListenerOverride.bind(this);
|
|
jibo.timer.setTimeout = this.setTimeoutOverride.bind(this);
|
|
jibo.timer.clearTimeout = this.clearTimeoutOverride.bind(this);
|
|
jibo.timer.setInterval = this.setIntervalOverride.bind(this);
|
|
jibo.timer.clearInterval = this.clearIntervalOverride.bind(this);
|
|
}
|
|
restore() {
|
|
if (this._initRan) {
|
|
jibo.timer.on = this._originalOn;
|
|
jibo.timer.off = jibo.timer.removeListener = this._originalRemoveListener;
|
|
jibo.timer.setTimeout = this._originalSetTimeout;
|
|
jibo.timer.clearTimeout = this._originalClearTimeout;
|
|
jibo.timer.setInterval = this._originalSetInterval;
|
|
jibo.timer.clearInterval = this._originalClearInterval;
|
|
}
|
|
}
|
|
getCurrentSkillTimers(skillName) {
|
|
if (!this._skillTimers[skillName]) {
|
|
this._skillTimers[skillName] = new Map();
|
|
}
|
|
return this._skillTimers[skillName];
|
|
}
|
|
checkSkillCleanup() {
|
|
let skillTimers = this.getCurrentSkillTimers(this._getCurrentSkillNameCallback());
|
|
if (skillTimers.size !== 0) {
|
|
log.error("The current skill has uncleaned up timers!!", this._getCurrentSkillNameCallback(), skillTimers);
|
|
delete this._skillTimers[this._getCurrentSkillNameCallback()];
|
|
}
|
|
else {
|
|
log.info("The current skill cleaned up all timers", this._getCurrentSkillNameCallback());
|
|
}
|
|
}
|
|
onOverride(event, method) {
|
|
const skillName = method.isGlobalTimer ? this._globalTimerSymbol : this._getCurrentSkillNameCallback();
|
|
let skillTimers = this.getCurrentSkillTimers(skillName);
|
|
let eventMethodSet = null;
|
|
if (!skillTimers.has(event)) {
|
|
eventMethodSet = new Set();
|
|
skillTimers.set(event, eventMethodSet);
|
|
}
|
|
else {
|
|
eventMethodSet = skillTimers.get(event);
|
|
}
|
|
if (eventMethodSet.has(method)) {
|
|
log.error("Found timeout being set from skill: ", skillName, method);
|
|
eventMethodSet.delete(method);
|
|
}
|
|
eventMethodSet.add(method);
|
|
return this._originalOn(event, method);
|
|
}
|
|
removeListenerOverride(event, method) {
|
|
const skillName = method.isGlobalTimer ? this._globalTimerSymbol : this._getCurrentSkillNameCallback();
|
|
let skillTimers = this.getCurrentSkillTimers(skillName);
|
|
let eventMethodSet = skillTimers.get(event);
|
|
if (eventMethodSet) {
|
|
eventMethodSet.delete(method);
|
|
if (eventMethodSet.size === 0) {
|
|
skillTimers.delete(event);
|
|
}
|
|
}
|
|
return this._originalRemoveListener(event, method);
|
|
}
|
|
setTimeoutOverride(callback, delay, useFrames, autoDestroy) {
|
|
const skillName = callback.isGlobalTimer ? this._globalTimerSymbol : this._getCurrentSkillNameCallback();
|
|
let skillTimers = this.getCurrentSkillTimers(skillName);
|
|
if (skillTimers.has(callback)) {
|
|
log.error("Found timeout being set from skill: ", skillName, callback);
|
|
skillTimers.delete(callback);
|
|
}
|
|
let delayedCall = this._originalSetTimeout(callback, delay, useFrames, autoDestroy);
|
|
delayedCall.isGlobalTimer = callback.isGlobalTimer;
|
|
let currentSkillTimers = this.getCurrentSkillTimers(this._getCurrentSkillNameCallback());
|
|
if (callback.isGlobalTimer && currentSkillTimers &&
|
|
currentSkillTimers.get("update") &&
|
|
currentSkillTimers.get("update").has(delayedCall._update)) {
|
|
currentSkillTimers.get("update").delete(delayedCall._update);
|
|
if (currentSkillTimers.get("update").size === 0) {
|
|
currentSkillTimers.delete("update");
|
|
}
|
|
}
|
|
skillTimers.set(delayedCall, callback);
|
|
const originalDestroy = delayedCall.destroy.bind(delayedCall);
|
|
delayedCall.destroy = () => {
|
|
originalDestroy();
|
|
this.clearTimeoutOverride(delayedCall);
|
|
};
|
|
return delayedCall;
|
|
}
|
|
clearTimeoutOverride(delayedCall) {
|
|
const skillName = delayedCall.isGlobalTimer ? this._globalTimerSymbol : this._getCurrentSkillNameCallback();
|
|
let skillTimers = this.getCurrentSkillTimers(skillName);
|
|
if (skillTimers.get(delayedCall)) {
|
|
skillTimers.delete(delayedCall);
|
|
return this._originalClearTimeout(delayedCall);
|
|
}
|
|
return;
|
|
}
|
|
setIntervalOverride(callback, delay, useFrames) {
|
|
const skillName = callback.isGlobalTimer ? this._globalTimerSymbol : this._getCurrentSkillNameCallback();
|
|
let skillTimers = this.getCurrentSkillTimers(skillName);
|
|
if (skillTimers.has(callback)) {
|
|
log.error("Found interval being set from skill: ", skillName, callback);
|
|
skillTimers.delete(callback);
|
|
}
|
|
let delayedCall = this._originalSetInterval(callback, delay, useFrames);
|
|
delayedCall.isGlobalTimer = callback.isGlobalTimer;
|
|
let currentSkillTimers = this.getCurrentSkillTimers(this._getCurrentSkillNameCallback());
|
|
if (callback.isGlobalTimer && currentSkillTimers &&
|
|
currentSkillTimers.get("update") &&
|
|
currentSkillTimers.get("update").has(delayedCall._update)) {
|
|
currentSkillTimers.get("update").delete(delayedCall._update);
|
|
if (currentSkillTimers.get("update").size === 0) {
|
|
currentSkillTimers.delete("update");
|
|
}
|
|
}
|
|
skillTimers.set(delayedCall, callback);
|
|
const originalDestroy = delayedCall.destroy.bind(delayedCall);
|
|
delayedCall.destroy = () => {
|
|
originalDestroy();
|
|
this.clearIntervalOverride(delayedCall);
|
|
};
|
|
return delayedCall;
|
|
}
|
|
clearIntervalOverride(delayedCall) {
|
|
const skillName = delayedCall.isGlobalTimer ? this._globalTimerSymbol : this._getCurrentSkillNameCallback();
|
|
let skillTimers = this.getCurrentSkillTimers(skillName);
|
|
if (skillTimers.get(delayedCall)) {
|
|
skillTimers.delete(delayedCall);
|
|
return this._originalClearInterval(delayedCall);
|
|
}
|
|
return;
|
|
}
|
|
destroy() {
|
|
this._initRan = false;
|
|
this._skillTimers = {};
|
|
}
|
|
}
|
|
exports.default = TimerSpy;
|
|
|
|
},{"./log":14,"jibo":undefined}],13:[function(require,module,exports){
|
|
"use strict";
|
|
const Be_1 = require("./Be");
|
|
module.exports = Be_1.default;
|
|
|
|
},{"./Be":1}],14:[function(require,module,exports){
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const jibo_log_1 = require("jibo-log");
|
|
const jibo = require("jibo");
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
jibo_log_1.Log.processName = "be";
|
|
const log = new jibo_log_1.Log('Be');
|
|
exports.default = log;
|
|
function loadLogConfig(callback) {
|
|
if (jibo.runMode === jibo.RunMode.ON_ROBOT) {
|
|
jibo.systemManager.getMode((err, mode) => {
|
|
const configPath = path.join(jibo.utils.PathUtils.findRoot(), 'config', `be-${mode}.json`);
|
|
if (fs.existsSync(configPath)) {
|
|
let encounteredError = false;
|
|
try {
|
|
jibo_log_1.Log.loadConfig(JSON.parse(fs.readFileSync(configPath, 'utf-8')));
|
|
log.info(`Loaded log configuration from '${configPath}'`);
|
|
}
|
|
catch (err) {
|
|
encounteredError = true;
|
|
callback(`Error parsing logging config file '${configPath}': ${err.message}`);
|
|
}
|
|
if (!encounteredError) {
|
|
callback();
|
|
}
|
|
}
|
|
else {
|
|
callback(`No logging configuration found at '${configPath}'`);
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
jibo_log_1.Log.loadConfig({});
|
|
callback();
|
|
}
|
|
}
|
|
exports.loadLogConfig = loadLogConfig;
|
|
|
|
},{"fs":undefined,"jibo":undefined,"jibo-log":undefined,"path":undefined}]},{},[13])(13)
|
|
});
|
|
//# sourceMappingURL=index.js.map
|