zephyr-agent
Version:
Zephyr plugin agent
396 lines (395 loc) • 21.5 kB
JavaScript
;
const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
}();
var __webpack_modules__ = {
"../errors" (module) {
module.exports = require("../errors/index.js");
},
"../http/http-request" (module) {
module.exports = require("../http/http-request.js");
},
"../logging" (module) {
module.exports = require("../logging/index.js");
},
"../logging/picocolor" (module) {
module.exports = require("../logging/picocolor.js");
},
"../logging/ze-log-event" (module) {
module.exports = require("../logging/ze-log-event.js");
},
"../node-persist/ci-token" (module) {
module.exports = require("../node-persist/ci-token.js");
},
"../node-persist/secret-token" (module) {
module.exports = require("../node-persist/secret-token.js");
},
"../node-persist/server-token" (module) {
module.exports = require("../node-persist/server-token.js");
},
"../node-persist/session-lock" (module) {
module.exports = require("../node-persist/session-lock.js");
},
"../node-persist/storage-keys" (module) {
module.exports = require("../node-persist/storage-keys.js");
},
"../node-persist/token" (module) {
module.exports = require("../node-persist/token.js");
},
"../security/redaction" (module) {
module.exports = require("../security/redaction.js");
},
"./auth-flags" (module) {
module.exports = require("./auth-flags.js");
},
"./sse" (module) {
module.exports = require("./sse.js");
},
"./token-expiry" (module) {
module.exports = require("./token-expiry.js");
},
"ci-info" (module) {
module.exports = require("ci-info");
},
"node:fs" (module) {
module.exports = require("node:fs");
},
"node:os" (module) {
module.exports = require("node:os");
},
"node:path" (module) {
module.exports = require("node:path");
},
"node:readline" (module) {
module.exports = require("node:readline");
},
"node:tty" (module) {
module.exports = require("node:tty");
},
"zephyr-edge-contract" (module) {
module.exports = require("zephyr-edge-contract");
}
};
var __webpack_module_cache__ = {};
function __webpack_require__(moduleId) {
var cachedModule = __webpack_module_cache__[moduleId];
if (void 0 !== cachedModule) return cachedModule.exports;
var module = __webpack_module_cache__[moduleId] = {
exports: {}
};
__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
return module.exports;
}
(()=>{
__webpack_require__.n = (module)=>{
var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
__webpack_require__.d(getter, {
a: getter
});
return getter;
};
})();
(()=>{
__webpack_require__.d = (exports1, getters, values)=>{
var define = (defs, kind)=>{
for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
enumerable: true,
[kind]: defs[key]
});
};
define(getters, "get");
define(values, "value");
};
})();
(()=>{
__webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
__webpack_require__.r = (exports1)=>{
if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
value: 'Module'
});
Object.defineProperty(exports1, '__esModule', {
value: true
});
};
})();
var __webpack_exports__ = {};
(()=>{
__webpack_require__.r(__webpack_exports__);
var ci_info__rspack_import_0 = __webpack_require__("ci-info");
var ci_info__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(ci_info__rspack_import_0);
var node_fs__rspack_import_1 = __webpack_require__("node:fs");
var node_fs__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(node_fs__rspack_import_1);
var node_os__rspack_import_2 = __webpack_require__("node:os");
var node_os__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(node_os__rspack_import_2);
var node_path__rspack_import_3 = __webpack_require__("node:path");
var node_path__rspack_import_3_default = /*#__PURE__*/ __webpack_require__.n(node_path__rspack_import_3);
var node_readline__rspack_import_4 = __webpack_require__("node:readline");
var node_readline__rspack_import_4_default = /*#__PURE__*/ __webpack_require__.n(node_readline__rspack_import_4);
var node_tty__rspack_import_5 = __webpack_require__("node:tty");
var node_tty__rspack_import_5_default = /*#__PURE__*/ __webpack_require__.n(node_tty__rspack_import_5);
var zephyr_edge_contract__rspack_import_6 = __webpack_require__("zephyr-edge-contract");
var zephyr_edge_contract__rspack_import_6_default = /*#__PURE__*/ __webpack_require__.n(zephyr_edge_contract__rspack_import_6);
var _errors__rspack_import_7 = __webpack_require__("../errors");
var _errors__rspack_import_7_default = /*#__PURE__*/ __webpack_require__.n(_errors__rspack_import_7);
var _http_http_request__rspack_import_8 = __webpack_require__("../http/http-request");
var _http_http_request__rspack_import_8_default = /*#__PURE__*/ __webpack_require__.n(_http_http_request__rspack_import_8);
var _logging__rspack_import_9 = __webpack_require__("../logging");
var _logging__rspack_import_9_default = /*#__PURE__*/ __webpack_require__.n(_logging__rspack_import_9);
var _logging_picocolor__rspack_import_10 = __webpack_require__("../logging/picocolor");
var _logging_picocolor__rspack_import_10_default = /*#__PURE__*/ __webpack_require__.n(_logging_picocolor__rspack_import_10);
var _logging_ze_log_event__rspack_import_11 = __webpack_require__("../logging/ze-log-event");
var _logging_ze_log_event__rspack_import_11_default = /*#__PURE__*/ __webpack_require__.n(_logging_ze_log_event__rspack_import_11);
var _node_persist_secret_token__rspack_import_12 = __webpack_require__("../node-persist/secret-token");
var _node_persist_secret_token__rspack_import_12_default = /*#__PURE__*/ __webpack_require__.n(_node_persist_secret_token__rspack_import_12);
var _node_persist_session_lock__rspack_import_13 = __webpack_require__("../node-persist/session-lock");
var _node_persist_session_lock__rspack_import_13_default = /*#__PURE__*/ __webpack_require__.n(_node_persist_session_lock__rspack_import_13);
var _node_persist_storage_keys__rspack_import_14 = __webpack_require__("../node-persist/storage-keys");
var _node_persist_storage_keys__rspack_import_14_default = /*#__PURE__*/ __webpack_require__.n(_node_persist_storage_keys__rspack_import_14);
var _node_persist_token__rspack_import_15 = __webpack_require__("../node-persist/token");
var _node_persist_token__rspack_import_15_default = /*#__PURE__*/ __webpack_require__.n(_node_persist_token__rspack_import_15);
var _sse__rspack_import_16 = __webpack_require__("./sse");
var _sse__rspack_import_16_default = /*#__PURE__*/ __webpack_require__.n(_sse__rspack_import_16);
var _auth_flags__rspack_import_17 = __webpack_require__("./auth-flags");
var _auth_flags__rspack_import_17_default = /*#__PURE__*/ __webpack_require__.n(_auth_flags__rspack_import_17);
var _token_expiry__rspack_import_18 = __webpack_require__("./token-expiry");
var _token_expiry__rspack_import_18_default = /*#__PURE__*/ __webpack_require__.n(_token_expiry__rspack_import_18);
var _node_persist_ci_token__rspack_import_19 = __webpack_require__("../node-persist/ci-token");
var _node_persist_ci_token__rspack_import_19_default = /*#__PURE__*/ __webpack_require__.n(_node_persist_ci_token__rspack_import_19);
var _node_persist_server_token__rspack_import_20 = __webpack_require__("../node-persist/server-token");
var _node_persist_server_token__rspack_import_20_default = /*#__PURE__*/ __webpack_require__.n(_node_persist_server_token__rspack_import_20);
var _security_redaction__rspack_import_21 = __webpack_require__("../security/redaction");
var _security_redaction__rspack_import_21_default = /*#__PURE__*/ __webpack_require__.n(_security_redaction__rspack_import_21);
function _ts_add_disposable_resource(env, value, async) {
if (null != value) {
if ("object" != typeof value && "function" != typeof value) throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (void 0 === dispose) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async) inner = dispose;
}
if ("function" != typeof dispose) throw new TypeError("Object not disposable.");
if (inner) dispose = function() {
try {
inner.call(this);
} catch (e) {
return Promise.reject(e);
}
};
env.stack.push({
value: value,
dispose: dispose,
async: async
});
} else if (async) env.stack.push({
async: true
});
return value;
}
var _SuppressedError1 = null;
function _ts_dispose_resources(env) {
function fail(e) {
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while(r = env.stack.pop())try {
if (!r.async && 1 === s) return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
fail(e);
return next();
});
} else s |= 1;
} catch (e) {
fail(e);
}
if (1 === s) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
}
async function checkAuth(git_config) {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const secret_token = (0, _node_persist_secret_token__rspack_import_12.getSecretToken)();
const server_token = (0, _node_persist_server_token__rspack_import_20.getServerToken)();
const ci_token = (0, _node_persist_ci_token__rspack_import_19.getCiToken)();
if (secret_token) return void (0, _logging_ze_log_event__rspack_import_11.logFn)('debug', 'Token found in environment. Using secret token for authentication.');
if (server_token) (0, _logging_ze_log_event__rspack_import_11.logFn)('debug', 'Server token found in environment. Using server token for authentication.');
if (ci_token) (0, _logging_ze_log_event__rspack_import_11.logFn)('debug', 'CI token found in environment. Using CI-inferred token attribution.');
const existingToken = await (0, _node_persist_token__rspack_import_15.getToken)(git_config);
if (existingToken) {
if ((0, _token_expiry__rspack_import_18.isTokenStillValid)(existingToken, _auth_flags__rspack_import_17.TOKEN_EXPIRY.SHORT_VALIDITY_CHECK_SEC)) return void _logging__rspack_import_9.ze_log.auth('You are already logged in');
await (0, _node_persist_token__rspack_import_15.removeToken)();
}
if (ci_info__rspack_import_0.isCI || !(0, node_tty__rspack_import_5.isatty)(process.stdin.fd) || !(0, node_tty__rspack_import_5.isatty)(process.stdout.fd)) {
(0, _logging_ze_log_event__rspack_import_11.logFn)('warn', `Could not load ${_node_persist_storage_keys__rspack_import_14.StorageKeys.ze_secret_token}.`);
throw new _errors__rspack_import_7.ZephyrError(_errors__rspack_import_7.ZeErrors.ERR_AUTH_ERROR, {
message: 'Interactive login is unavailable. Run the deployment in a terminal or provide a valid authentication token.'
});
}
(0, _logging_ze_log_event__rspack_import_11.logFn)('', `${(0, _logging_picocolor__rspack_import_10.yellow)('Authentication required')} - You need to log in to Zephyr Cloud`);
const sessionKey = _ts_add_disposable_resource(env, (0, _node_persist_session_lock__rspack_import_13.getSessionKey)(), false);
const authUrl = await getAuthenticationURL(sessionKey.session);
if (!sessionKey.owner) (0, _logging_ze_log_event__rspack_import_11.logFn)('', (0, _logging_picocolor__rspack_import_10.gray)('Waiting for session unlock...'));
const browserController = new AbortController();
let privateAuthenticationArtifact;
promptForAuthAction(authUrl, browserController.signal).then(()=>openUrl(authUrl)).catch(()=>{
if (!browserController.signal.aborted) privateAuthenticationArtifact = fallbackManualLogin(authUrl);
}).finally(()=>{
if (browserController.signal.aborted) privateAuthenticationArtifact?.cleanup();
});
try {
if (sessionKey.owner) {
const newToken = await waitForAccessToken(sessionKey.session);
await (0, _node_persist_token__rspack_import_15.saveToken)(newToken);
} else {
await (0, _node_persist_session_lock__rspack_import_13.waitForUnlock)(browserController.signal);
const token = await (0, _node_persist_token__rspack_import_15.getToken)(git_config);
if (!token) throw new _errors__rspack_import_7.ZephyrError(_errors__rspack_import_7.ZeErrors.ERR_AUTH_ERROR, {
message: 'No token found after authentication finished, did it timeout?'
});
}
} finally{
browserController.abort();
privateAuthenticationArtifact?.cleanup();
}
(0, _logging_ze_log_event__rspack_import_11.logFn)('', `${(0, _logging_picocolor__rspack_import_10.green)('✓')} You are now logged in to Zephyr Cloud\n`);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
async function promptForAuthAction(authUrl, signal) {
const rl = node_readline__rspack_import_4.createInterface({
input: process.stdin,
output: process.stdout,
signal
});
return new Promise((resolve)=>{
rl.question(formatAuthenticationPromptForTerminal(authUrl), {
signal
}, resolve);
});
}
function formatAuthenticationPromptForTerminal(authUrl, interactive = _logging_picocolor__rspack_import_10.isTTY) {
if (!interactive) return (0, _logging_ze_log_event__rspack_import_11.formatLogMsg)('\nA private authentication link was generated. Waiting for browser authentication.\n');
return [
(0, _logging_ze_log_event__rspack_import_11.formatLogMsg)('\nAuthentication URL (shown only in this terminal):'),
authUrl,
(0, _logging_ze_log_event__rspack_import_11.formatLogMsg)(`\n${(0, _logging_picocolor__rspack_import_10.gray)(`Hit ${(0, _logging_picocolor__rspack_import_10.bold)((0, _logging_picocolor__rspack_import_10.white)('Enter'))} to open it in your browser.`)}\n`)
].join('\n');
}
function fallbackManualLogin(url) {
(0, _logging_ze_log_event__rspack_import_11.logFn)('', '');
(0, _logging_ze_log_event__rspack_import_11.logFn)('', "An unexpected error happened when opening the browser.");
let artifact;
try {
artifact = createPrivateAuthenticationArtifact(url);
} catch {
(0, _logging_ze_log_event__rspack_import_11.logFn)('error', 'Could not create a private authentication link. Please retry in an environment that can open a browser.');
return;
}
try {
(0, _logging_ze_log_event__rspack_import_11.logFn)('', `${(0, _logging_picocolor__rspack_import_10.yellow)('Please open this private HTML file in your browser:')}`);
(0, _logging_ze_log_event__rspack_import_11.logFn)('', artifact.filePath);
(0, _logging_ze_log_event__rspack_import_11.logFn)('', `${(0, _logging_picocolor__rspack_import_10.blue)('⏳')} Waiting for you to complete authentication in browser...`);
return artifact;
} catch {
artifact.cleanup();
return;
}
}
function createPrivateAuthenticationArtifact(url, writeArtifact = node_fs__rspack_import_1.writeFileSync) {
const directory = (0, node_fs__rspack_import_1.mkdtempSync)((0, node_path__rspack_import_3.join)((0, node_os__rspack_import_2.tmpdir)(), 'zephyr-auth-'));
const filePath = (0, node_path__rspack_import_3.join)(directory, 'login.html');
try {
(0, node_fs__rspack_import_1.chmodSync)(directory, 448);
const escapedUrl = url.replace(/&/gu, '&').replace(/</gu, '<').replace(/>/gu, '>').replace(/"/gu, '"').replace(/'/gu, ''');
writeArtifact(filePath, `<!doctype html><meta http-equiv="refresh" content="0;url=${escapedUrl}"><title>Zephyr authentication</title>`, {
encoding: 'utf8',
flag: 'wx',
mode: 384
});
} catch (error) {
try {
(0, node_fs__rspack_import_1.rmSync)(directory, {
force: true,
recursive: true
});
} catch {}
throw error;
}
return {
filePath,
cleanup: ()=>(0, node_fs__rspack_import_1.rmSync)(directory, {
force: true,
recursive: true
})
};
}
async function openUrl(url) {
const openModule = await eval("import('open')");
await openModule.default(url);
}
async function getAuthenticationURL(state) {
const authorizeUrl = new URL(zephyr_edge_contract__rspack_import_6.ze_api_gateway.authorize_link, (0, zephyr_edge_contract__rspack_import_6.ZE_API_ENDPOINT)());
authorizeUrl.searchParams.set('state', state);
_logging__rspack_import_9.ze_log.auth('getAuthenticationURL', (0, _security_redaction__rspack_import_21.redactUrl)(authorizeUrl));
const [ok, cause, data] = await (0, _http_http_request__rspack_import_8.makeRequest)({
path: zephyr_edge_contract__rspack_import_6.ze_api_gateway.authorize_link,
base: (0, zephyr_edge_contract__rspack_import_6.ZE_API_ENDPOINT)(),
query: {
state
}
});
if (!ok) throw new _errors__rspack_import_7.ZephyrError(_errors__rspack_import_7.ZeErrors.ERR_AUTH_ERROR, {
cause,
message: 'Could not get authentication URL'
});
return data;
}
async function waitForAccessToken(sessionKey) {
const url = new URL(zephyr_edge_contract__rspack_import_6.ze_api_gateway.websocket, (0, zephyr_edge_contract__rspack_import_6.ZE_API_ENDPOINT)());
url.searchParams.set('sessionId', sessionKey);
const authListener = new _sse__rspack_import_16.AuthListener(url);
const resp = await authListener.waitForToken();
(0, _logging__rspack_import_9.ze_debug)('waitForAccessToken', 'Received token for authentication session');
return resp.token;
}
__webpack_require__.d(__webpack_exports__, {
checkAuth: ()=>checkAuth,
createPrivateAuthenticationArtifact: ()=>createPrivateAuthenticationArtifact,
formatAuthenticationPromptForTerminal: ()=>formatAuthenticationPromptForTerminal,
isTokenStillValid: ()=>_token_expiry__rspack_import_18.isTokenStillValid
});
})();
exports.checkAuth = __webpack_exports__.checkAuth;
exports.createPrivateAuthenticationArtifact = __webpack_exports__.createPrivateAuthenticationArtifact;
exports.formatAuthenticationPromptForTerminal = __webpack_exports__.formatAuthenticationPromptForTerminal;
exports.isTokenStillValid = __webpack_exports__.isTokenStillValid;
for(var __rspack_i in __webpack_exports__)if (-1 === [
"checkAuth",
"createPrivateAuthenticationArtifact",
"formatAuthenticationPromptForTerminal",
"isTokenStillValid"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
value: true
});
//# sourceMappingURL=login.js.map