@systemfsoftware/trigger.dev
Version:
A Command-Line Interface for Trigger.dev (v3) projects
1,490 lines (1,464 loc) • 267 kB
JavaScript
#!/usr/bin/env node
import { createRequire as createRequireFromMetaUrl } from 'node:module';const require = createRequireFromMetaUrl(import.meta.url);
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined")
return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js
var require_XDGAppPaths = __commonJS({
"../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/lib/XDGAppPaths.js"(exports) {
"use strict";
exports.__esModule = true;
exports.Adapt = void 0;
function isBoolean(t) {
return typeOf(t) === "boolean";
}
function isObject(t) {
return typeOf(t) === "object";
}
function isString(t) {
return typeOf(t) === "string";
}
function typeOf(t) {
return typeof t;
}
function Adapt(adapter_) {
var meta = adapter_.meta, path7 = adapter_.path, xdg = adapter_.xdg;
var XDGAppPaths_ = /* @__PURE__ */ function() {
function XDGAppPaths_2(options_) {
if (options_ === void 0) {
options_ = {};
}
var _a, _b, _c;
function XDGAppPaths(options2) {
if (options2 === void 0) {
options2 = {};
}
return new XDGAppPaths_2(options2);
}
var options = isObject(options_) ? options_ : { name: options_ };
var suffix = (_a = options.suffix) !== null && _a !== void 0 ? _a : "";
var isolated_ = (_b = options.isolated) !== null && _b !== void 0 ? _b : true;
var namePriorityList = [
options.name,
meta.pkgMainFilename(),
meta.mainFilename()
];
var nameFallback = "$eval";
var name = path7.parse(((_c = namePriorityList.find(function(e) {
return isString(e);
})) !== null && _c !== void 0 ? _c : nameFallback) + suffix).name;
XDGAppPaths.$name = function $name() {
return name;
};
XDGAppPaths.$isolated = function $isolated() {
return isolated_;
};
function isIsolated(dirOptions) {
var _a2;
dirOptions = dirOptions !== null && dirOptions !== void 0 ? dirOptions : { isolated: isolated_ };
var isolated = isBoolean(dirOptions) ? dirOptions : (_a2 = dirOptions.isolated) !== null && _a2 !== void 0 ? _a2 : isolated_;
return isolated;
}
function finalPathSegment(dirOptions) {
return isIsolated(dirOptions) ? name : "";
}
XDGAppPaths.cache = function cache(dirOptions) {
return path7.join(xdg.cache(), finalPathSegment(dirOptions));
};
XDGAppPaths.config = function config(dirOptions) {
return path7.join(xdg.config(), finalPathSegment(dirOptions));
};
XDGAppPaths.data = function data(dirOptions) {
return path7.join(xdg.data(), finalPathSegment(dirOptions));
};
XDGAppPaths.runtime = function runtime(dirOptions) {
return xdg.runtime() ? path7.join(xdg.runtime(), finalPathSegment(dirOptions)) : void 0;
};
XDGAppPaths.state = function state(dirOptions) {
return path7.join(xdg.state(), finalPathSegment(dirOptions));
};
XDGAppPaths.configDirs = function configDirs(dirOptions) {
return xdg.configDirs().map(function(s) {
return path7.join(s, finalPathSegment(dirOptions));
});
};
XDGAppPaths.dataDirs = function dataDirs(dirOptions) {
return xdg.dataDirs().map(function(s) {
return path7.join(s, finalPathSegment(dirOptions));
});
};
return XDGAppPaths;
}
return XDGAppPaths_2;
}();
return { XDGAppPaths: new XDGAppPaths_() };
}
exports.Adapt = Adapt;
}
});
// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js
var require_XDG = __commonJS({
"../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/lib/XDG.js"(exports) {
"use strict";
var __spreadArray = exports && exports.__spreadArray || function(to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
to[j] = from[i];
return to;
};
exports.__esModule = true;
exports.Adapt = void 0;
function Adapt(adapter_) {
var env = adapter_.env, osPaths = adapter_.osPaths, path7 = adapter_.path;
var isMacOS = /^darwin$/i.test(adapter_.process.platform);
var isWinOS = /^win/i.test(adapter_.process.platform);
function baseDir() {
return osPaths.home() || osPaths.temp();
}
function valOrPath(val, pathSegments) {
return val || path7.join.apply(path7, pathSegments);
}
var linux = function() {
var cache = function() {
return valOrPath(env.get("XDG_CACHE_HOME"), [baseDir(), ".cache"]);
};
var config = function() {
return valOrPath(env.get("XDG_CONFIG_HOME"), [baseDir(), ".config"]);
};
var data = function() {
return valOrPath(env.get("XDG_DATA_HOME"), [baseDir(), ".local", "share"]);
};
var runtime = function() {
return env.get("XDG_RUNTIME_DIR") || void 0;
};
var state = function() {
return valOrPath(env.get("XDG_STATE_HOME"), [baseDir(), ".local", "state"]);
};
return { cache, config, data, runtime, state };
};
var macos = function() {
var cache = function() {
return valOrPath(env.get("XDG_CACHE_HOME"), [baseDir(), "Library", "Caches"]);
};
var config = function() {
return valOrPath(env.get("XDG_CONFIG_HOME"), [baseDir(), "Library", "Preferences"]);
};
var data = function() {
return valOrPath(env.get("XDG_DATA_HOME"), [baseDir(), "Library", "Application Support"]);
};
var runtime = function() {
return env.get("XDG_RUNTIME_DIR") || void 0;
};
var state = function() {
return valOrPath(env.get("XDG_STATE_HOME"), [baseDir(), "Library", "State"]);
};
return { cache, config, data, runtime, state };
};
var windows = function() {
function appData() {
return valOrPath(env.get("APPDATA"), [baseDir(), "AppData", "Roaming"]);
}
function localAppData() {
return valOrPath(env.get("LOCALAPPDATA"), [baseDir(), "AppData", "Local"]);
}
var cache = function() {
return valOrPath(env.get("XDG_CACHE_HOME"), [localAppData(), "xdg.cache"]);
};
var config = function() {
return valOrPath(env.get("XDG_CONFIG_HOME"), [appData(), "xdg.config"]);
};
var data = function() {
return valOrPath(env.get("XDG_DATA_HOME"), [appData(), "xdg.data"]);
};
var runtime = function() {
return env.get("XDG_RUNTIME_DIR") || void 0;
};
var state = function() {
return valOrPath(env.get("XDG_STATE_HOME"), [localAppData(), "xdg.state"]);
};
return { cache, config, data, runtime, state };
};
var XDG_ = /* @__PURE__ */ function() {
function XDG_2() {
function XDG() {
return new XDG_2();
}
var extension = isMacOS ? macos() : isWinOS ? windows() : linux();
XDG.cache = extension.cache;
XDG.config = extension.config;
XDG.data = extension.data;
XDG.runtime = extension.runtime;
XDG.state = extension.state;
XDG.configDirs = function configDirs() {
var pathList = env.get("XDG_CONFIG_DIRS");
return __spreadArray([extension.config()], pathList ? pathList.split(path7.delimiter) : []);
};
XDG.dataDirs = function dataDirs() {
var pathList = env.get("XDG_DATA_DIRS");
return __spreadArray([extension.data()], pathList ? pathList.split(path7.delimiter) : []);
};
return XDG;
}
return XDG_2;
}();
return { XDG: new XDG_() };
}
exports.Adapt = Adapt;
}
});
// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js
var require_OSPaths = __commonJS({
"../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/lib/OSPaths.js"(exports) {
"use strict";
var __spreadArray = exports && exports.__spreadArray || function(to, from) {
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
to[j] = from[i];
return to;
};
exports.__esModule = true;
exports.Adapt = void 0;
function isEmpty(s) {
return !s;
}
function Adapt(adapter_) {
var env = adapter_.env, os2 = adapter_.os, path7 = adapter_.path;
var isWinOS = /^win/i.test(adapter_.process.platform);
function normalizePath(path_) {
return path_ ? adapter_.path.normalize(adapter_.path.join(path_, ".")) : void 0;
}
function home() {
var posix2 = function() {
return normalizePath((typeof os2.homedir === "function" ? os2.homedir() : void 0) || env.get("HOME"));
};
var windows = function() {
var priorityList = [
typeof os2.homedir === "function" ? os2.homedir() : void 0,
env.get("USERPROFILE"),
env.get("HOME"),
env.get("HOMEDRIVE") || env.get("HOMEPATH") ? path7.join(env.get("HOMEDRIVE") || "", env.get("HOMEPATH") || "") : void 0
];
return normalizePath(priorityList.find(function(v) {
return !isEmpty(v);
}));
};
return isWinOS ? windows() : posix2();
}
function temp() {
function joinPathToBase(base, segments) {
return base ? path7.join.apply(path7, __spreadArray([base], segments)) : void 0;
}
function posix2() {
var fallback = "/tmp";
var priorityList = [
typeof os2.tmpdir === "function" ? os2.tmpdir() : void 0,
env.get("TMPDIR"),
env.get("TEMP"),
env.get("TMP")
];
return normalizePath(priorityList.find(function(v) {
return !isEmpty(v);
})) || fallback;
}
function windows() {
var fallback = "C:\\Temp";
var priorityListLazy = [
typeof os2.tmpdir === "function" ? os2.tmpdir : function() {
return void 0;
},
function() {
return env.get("TEMP");
},
function() {
return env.get("TMP");
},
function() {
return joinPathToBase(env.get("LOCALAPPDATA"), ["Temp"]);
},
function() {
return joinPathToBase(home(), ["AppData", "Local", "Temp"]);
},
function() {
return joinPathToBase(env.get("ALLUSERSPROFILE"), ["Temp"]);
},
function() {
return joinPathToBase(env.get("SystemRoot"), ["Temp"]);
},
function() {
return joinPathToBase(env.get("windir"), ["Temp"]);
},
function() {
return joinPathToBase(env.get("SystemDrive"), ["\\", "Temp"]);
}
];
var v = priorityListLazy.find(function(v2) {
return v2 && !isEmpty(v2());
});
return v && normalizePath(v()) || fallback;
}
return isWinOS ? windows() : posix2();
}
var OSPaths_ = /* @__PURE__ */ function() {
function OSPaths_2() {
function OSPaths() {
return new OSPaths_2();
}
OSPaths.home = home;
OSPaths.temp = temp;
return OSPaths;
}
return OSPaths_2;
}();
return { OSPaths: new OSPaths_() };
}
exports.Adapt = Adapt;
}
});
// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js
var require_node = __commonJS({
"../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/platform-adapters/node.js"(exports) {
"use strict";
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
} : function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
o[k2] = m[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || function(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null) {
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
exports.__esModule = true;
exports.adapter = void 0;
var os2 = __importStar(__require("os"));
var path7 = __importStar(__require("path"));
exports.adapter = {
atImportPermissions: { env: true },
env: {
get: function(s) {
return process.env[s];
}
},
os: os2,
path: path7,
process
};
}
});
// ../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js
var require_mod_cjs = __commonJS({
"../../node_modules/.pnpm/os-paths@7.4.0/node_modules/os-paths/dist/cjs/mod.cjs.js"(exports, module) {
"use strict";
var OSPaths_js_1 = require_OSPaths();
var node_js_1 = require_node();
module.exports = OSPaths_js_1.Adapt(node_js_1.adapter).OSPaths;
}
});
// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js
var require_node2 = __commonJS({
"../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/platform-adapters/node.js"(exports) {
"use strict";
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
} : function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
o[k2] = m[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || function(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null) {
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
exports.__esModule = true;
exports.adapter = void 0;
var path7 = __importStar(__require("path"));
var os_paths_1 = __importDefault(require_mod_cjs());
exports.adapter = {
atImportPermissions: { env: true },
env: {
get: function(s) {
return process.env[s];
}
},
osPaths: os_paths_1["default"],
path: path7,
process
};
}
});
// ../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js
var require_mod_cjs2 = __commonJS({
"../../node_modules/.pnpm/xdg-portable@10.6.0/node_modules/xdg-portable/dist/cjs/mod.cjs.js"(exports, module) {
"use strict";
var XDG_js_1 = require_XDG();
var node_js_1 = require_node2();
module.exports = XDG_js_1.Adapt(node_js_1.adapter).XDG;
}
});
// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js
var require_node3 = __commonJS({
"../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/platform-adapters/node.js"(exports) {
"use strict";
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() {
return m[k];
} });
} : function(o, m, k, k2) {
if (k2 === void 0)
k2 = k;
o[k2] = m[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || function(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null) {
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
}
__setModuleDefault(result, mod);
return result;
};
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
exports.__esModule = true;
exports.adapter = void 0;
var path7 = __importStar(__require("path"));
var xdg_portable_1 = __importDefault(require_mod_cjs2());
exports.adapter = {
atImportPermissions: { env: true, read: true },
meta: {
mainFilename: function() {
var requireMain = typeof __require !== "undefined" && __require !== null && __require.main ? __require.main : { filename: void 0 };
var requireMainFilename = requireMain.filename;
var filename = (requireMainFilename !== process.execArgv[0] ? requireMainFilename : void 0) || (typeof process._eval === "undefined" ? process.argv[1] : void 0);
return filename;
},
pkgMainFilename: function() {
return process.pkg ? process.execPath : void 0;
}
},
path: path7,
process,
xdg: xdg_portable_1["default"]
};
}
});
// ../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js
var require_mod_cjs3 = __commonJS({
"../../node_modules/.pnpm/xdg-app-paths@8.3.0/node_modules/xdg-app-paths/dist/cjs/mod.cjs.js"(exports, module) {
"use strict";
var XDGAppPaths_js_1 = require_XDGAppPaths();
var node_js_1 = require_node3();
module.exports = XDGAppPaths_js_1.Adapt(node_js_1.adapter).XDGAppPaths;
}
});
// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
var require_retry_operation = __commonJS({
"../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module) {
"use strict";
function RetryOperation(timeouts, options) {
if (typeof options === "boolean") {
options = { forever: options };
}
this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
this._timeouts = timeouts;
this._options = options || {};
this._maxRetryTime = options && options.maxRetryTime || Infinity;
this._fn = null;
this._errors = [];
this._attempts = 1;
this._operationTimeout = null;
this._operationTimeoutCb = null;
this._timeout = null;
this._operationStart = null;
this._timer = null;
if (this._options.forever) {
this._cachedTimeouts = this._timeouts.slice(0);
}
}
module.exports = RetryOperation;
RetryOperation.prototype.reset = function() {
this._attempts = 1;
this._timeouts = this._originalTimeouts.slice(0);
};
RetryOperation.prototype.stop = function() {
if (this._timeout) {
clearTimeout(this._timeout);
}
if (this._timer) {
clearTimeout(this._timer);
}
this._timeouts = [];
this._cachedTimeouts = null;
};
RetryOperation.prototype.retry = function(err) {
if (this._timeout) {
clearTimeout(this._timeout);
}
if (!err) {
return false;
}
var currentTime = (/* @__PURE__ */ new Date()).getTime();
if (err && currentTime - this._operationStart >= this._maxRetryTime) {
this._errors.push(err);
this._errors.unshift(new Error("RetryOperation timeout occurred"));
return false;
}
this._errors.push(err);
var timeout = this._timeouts.shift();
if (timeout === void 0) {
if (this._cachedTimeouts) {
this._errors.splice(0, this._errors.length - 1);
timeout = this._cachedTimeouts.slice(-1);
} else {
return false;
}
}
var self = this;
this._timer = setTimeout(function() {
self._attempts++;
if (self._operationTimeoutCb) {
self._timeout = setTimeout(function() {
self._operationTimeoutCb(self._attempts);
}, self._operationTimeout);
if (self._options.unref) {
self._timeout.unref();
}
}
self._fn(self._attempts);
}, timeout);
if (this._options.unref) {
this._timer.unref();
}
return true;
};
RetryOperation.prototype.attempt = function(fn, timeoutOps) {
this._fn = fn;
if (timeoutOps) {
if (timeoutOps.timeout) {
this._operationTimeout = timeoutOps.timeout;
}
if (timeoutOps.cb) {
this._operationTimeoutCb = timeoutOps.cb;
}
}
var self = this;
if (this._operationTimeoutCb) {
this._timeout = setTimeout(function() {
self._operationTimeoutCb();
}, self._operationTimeout);
}
this._operationStart = (/* @__PURE__ */ new Date()).getTime();
this._fn(this._attempts);
};
RetryOperation.prototype.try = function(fn) {
console.log("Using RetryOperation.try() is deprecated");
this.attempt(fn);
};
RetryOperation.prototype.start = function(fn) {
console.log("Using RetryOperation.start() is deprecated");
this.attempt(fn);
};
RetryOperation.prototype.start = RetryOperation.prototype.try;
RetryOperation.prototype.errors = function() {
return this._errors;
};
RetryOperation.prototype.attempts = function() {
return this._attempts;
};
RetryOperation.prototype.mainError = function() {
if (this._errors.length === 0) {
return null;
}
var counts = {};
var mainError = null;
var mainErrorCount = 0;
for (var i = 0; i < this._errors.length; i++) {
var error = this._errors[i];
var message = error.message;
var count = (counts[message] || 0) + 1;
counts[message] = count;
if (count >= mainErrorCount) {
mainError = error;
mainErrorCount = count;
}
}
return mainError;
};
}
});
// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
var require_retry = __commonJS({
"../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
"use strict";
var RetryOperation = require_retry_operation();
exports.operation = function(options) {
var timeouts = exports.timeouts(options);
return new RetryOperation(timeouts, {
forever: options && (options.forever || options.retries === Infinity),
unref: options && options.unref,
maxRetryTime: options && options.maxRetryTime
});
};
exports.timeouts = function(options) {
if (options instanceof Array) {
return [].concat(options);
}
var opts = {
retries: 10,
factor: 2,
minTimeout: 1 * 1e3,
maxTimeout: Infinity,
randomize: false
};
for (var key in options) {
opts[key] = options[key];
}
if (opts.minTimeout > opts.maxTimeout) {
throw new Error("minTimeout is greater than maxTimeout");
}
var timeouts = [];
for (var i = 0; i < opts.retries; i++) {
timeouts.push(this.createTimeout(i, opts));
}
if (options && options.forever && !timeouts.length) {
timeouts.push(this.createTimeout(i, opts));
}
timeouts.sort(function(a, b) {
return a - b;
});
return timeouts;
};
exports.createTimeout = function(attempt, opts) {
var random = opts.randomize ? Math.random() + 1 : 1;
var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
timeout = Math.min(timeout, opts.maxTimeout);
return timeout;
};
exports.wrap = function(obj, options, methods) {
if (options instanceof Array) {
methods = options;
options = null;
}
if (!methods) {
methods = [];
for (var key in obj) {
if (typeof obj[key] === "function") {
methods.push(key);
}
}
}
for (var i = 0; i < methods.length; i++) {
var method = methods[i];
var original = obj[method];
obj[method] = function retryWrapper(original2) {
var op = exports.operation(options);
var args = Array.prototype.slice.call(arguments, 1);
var callback = args.pop();
args.push(function(err) {
if (op.retry(err)) {
return;
}
if (err) {
arguments[0] = op.mainError();
}
callback.apply(this, arguments);
});
op.attempt(function() {
original2.apply(obj, args);
});
}.bind(obj, original);
obj[method].options = options;
}
};
}
});
// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
var require_retry2 = __commonJS({
"../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module) {
"use strict";
module.exports = require_retry();
}
});
// src/cli/index.ts
import { Command as Command2 } from "commander";
// src/commands/deploy.ts
import { intro as intro4, log as log5, outro as outro5 } from "@clack/prompts";
import { depot } from "@depot/cli";
import { context, trace as trace2 } from "@opentelemetry/api";
import {
TaskMetadataFailedToParseData,
detectDependencyVersion,
flattenAttributes as flattenAttributes3
} from "@systemfsoftware/trigger.dev_core/v3";
import { recordSpanException as recordSpanException5 } from "@systemfsoftware/trigger.dev_core/v3/workers";
import { Option as CommandOption } from "commander";
import { build as build2 } from "esbuild";
import { execa as execa2 } from "execa";
import { createHash } from "node:crypto";
import { readFileSync as readFileSync2 } from "node:fs";
import { copyFile, mkdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
import { dirname, join as join6, posix, relative as relative3 } from "node:path";
import { setTimeout as setTimeout2 } from "node:timers/promises";
import invariant from "tiny-invariant";
import { z as z4 } from "zod";
// package.json
var version = "2.3.19";
var dependencies = {
"@anatine/esbuild-decorators": "^0.2.19",
"@clack/prompts": "^0.7.0",
"@depot/cli": "0.0.1-cli.2.71.0",
"@opentelemetry/api": "^1.8.0",
"@opentelemetry/api-logs": "^0.49.1",
"@opentelemetry/exporter-logs-otlp-http": "^0.49.1",
"@opentelemetry/exporter-trace-otlp-http": "^0.49.1",
"@opentelemetry/instrumentation": "^0.49.1",
"@opentelemetry/instrumentation-fetch": "^0.49.1",
"@opentelemetry/resources": "^1.22.0",
"@opentelemetry/sdk-logs": "^0.49.1",
"@opentelemetry/sdk-node": "^0.49.1",
"@opentelemetry/sdk-trace-base": "^1.22.0",
"@opentelemetry/sdk-trace-node": "^1.22.0",
"@opentelemetry/semantic-conventions": "^1.22.0",
"@systemfsoftware/trigger.dev_core": "workspace:2.3.19",
"@types/degit": "^2.8.3",
chalk: "^5.2.0",
chokidar: "^3.5.3",
"cli-table3": "^0.6.3",
commander: "^9.4.1",
degit: "^2.8.4",
dotenv: "^16.4.4",
esbuild: "^0.19.11",
evt: "^2.4.13",
execa: "^9.1.0",
"find-up": "^7.0.0",
glob: "^10.3.10",
"gradient-string": "^2.0.2",
"import-meta-resolve": "^4.0.0",
ink: "^4.4.1",
"jsonc-parser": "3.2.1",
liquidjs: "^10.9.2",
"mock-fs": "^5.2.0",
nanoid: "^4.0.2",
"node-fetch": "^3.3.0",
"object-hash": "^3.0.0",
"p-debounce": "^4.0.0",
"p-throttle": "^6.1.0",
partysocket: "^0.0.17",
"proxy-agent": "^6.3.0",
react: "^18.2.0",
"react-error-boundary": "^4.0.12",
semver: "^7.5.0",
"simple-git": "^3.19.0",
"source-map-support": "^0.5.21",
"terminal-link": "^3.0.0",
"tiny-invariant": "^1.2.0",
"tsconfig-paths": "^4.2.0",
typescript: "^5.4.0",
"update-check": "^1.5.4",
url: "^0.11.1",
ws: "^8.12.0",
zod: "3.22.3",
"zod-validation-error": "^1.5.0"
};
var package_default = {
name: "@systemfsoftware/trigger.dev",
version,
description: "A Command-Line Interface for Trigger.dev (v3) projects",
main: "./dist/index.js",
types: "./dist/index.d.ts",
license: "MIT",
repository: {
type: "git",
url: "https://github.com/triggerdotdev/trigger.dev.git",
directory: "packages/cli-v3"
},
publishConfig: {
access: "public"
},
keywords: [
"typescript",
"trigger.dev",
"workflows",
"orchestration",
"events",
"webhooks",
"integrations",
"apis",
"jobs",
"background jobs",
"nextjs"
],
files: [
"dist"
],
type: "module",
exports: "./dist/index.js",
bin: {
triggerdev: "./dist/index.js"
},
devDependencies: {
"@systemfsoftware/trigger.dev_core-apps": "workspace:*",
"@systemfsoftware/trigger.dev_tsconfig": "workspace:*",
"@types/gradient-string": "^1.1.2",
"@types/mock-fs": "^4.13.1",
"@types/node": "^20.16.2",
"@types/object-hash": "^3.0.6",
"@types/react": "^18.2.48",
"@types/semver": "^7.3.13",
"@types/ws": "^8.5.3",
"cpy-cli": "^5.0.0",
nodemon: "^3.0.1",
"npm-run-all": "^4.1.5",
open: "^10.0.3",
"p-retry": "^6.1.0",
rimraf: "^5.0.7",
tsup: "8.0.1",
"type-fest": "^3.6.0",
typescript: "^5.3.3",
vitest: "^1.6.0",
"xdg-app-paths": "^8.3.0"
},
scripts: {
typecheck: "tsc -p tsconfig.check.json",
build: "npm run clean && run-p build:**",
"build:main": "tsup",
"build:workers": "tsup --config tsup.workers.config.ts",
"build:prod-containerfile": "cpy --flat src/Containerfile.prod dist/",
dev: "npm run clean && run-p dev:**",
"dev:main": "tsup --watch",
"dev:workers": "tsup --config tsup.workers.config.ts --watch",
"dev:test": "nodemon -w src/Containerfile.prod -x npm run build:prod-containerfile",
clean: "rimraf dist",
start: "node dist/index.js",
test: "vitest",
"test:e2e": "vitest --run -c e2e/vite.config.js"
},
dependencies,
engines: {
node: ">=18.0.0"
}
};
// src/apiClient.ts
import {
CreateAuthorizationCodeResponseSchema,
GetPersonalAccessTokenResponseSchema,
WhoAmIResponseSchema,
CreateBackgroundWorkerResponse,
StartDeploymentIndexingResponseBody,
GetProjectEnvResponse,
GetEnvironmentVariablesResponseBody,
InitializeDeploymentResponseBody,
GetDeploymentResponseBody,
GetProjectsResponseBody,
GetProjectResponseBody,
EnvironmentVariableResponseBody,
TaskRunExecution
} from "@systemfsoftware/trigger.dev_core/v3";
import { zodfetch, ApiError } from "@systemfsoftware/trigger.dev_core/v3/zodfetch";
var CliApiClient = class {
constructor(apiURL, accessToken) {
this.accessToken = accessToken;
this.apiURL = apiURL.replace(/\/$/, "");
}
apiURL;
async createAuthorizationCode() {
return wrapZodFetch(
CreateAuthorizationCodeResponseSchema,
`${this.apiURL}/api/v1/authorization-code`,
{
method: "POST"
}
);
}
async getPersonalAccessToken(authorizationCode) {
return wrapZodFetch(GetPersonalAccessTokenResponseSchema, `${this.apiURL}/api/v1/token`, {
method: "POST",
body: JSON.stringify({
authorizationCode
})
});
}
async whoAmI() {
if (!this.accessToken) {
throw new Error("whoAmI: No access token");
}
return wrapZodFetch(WhoAmIResponseSchema, `${this.apiURL}/api/v2/whoami`, {
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
}
});
}
async getProject(projectRef) {
if (!this.accessToken) {
throw new Error("getProject: No access token");
}
return wrapZodFetch(GetProjectResponseBody, `${this.apiURL}/api/v1/projects/${projectRef}`, {
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
}
});
}
async getProjects() {
if (!this.accessToken) {
throw new Error("getProjects: No access token");
}
return wrapZodFetch(GetProjectsResponseBody, `${this.apiURL}/api/v1/projects`, {
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
}
});
}
async createBackgroundWorker(projectRef, body) {
if (!this.accessToken) {
throw new Error("createBackgroundWorker: No access token");
}
return wrapZodFetch(
CreateBackgroundWorkerResponse,
`${this.apiURL}/api/v1/projects/${projectRef}/background-workers`,
{
method: "POST",
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
},
body: JSON.stringify(body)
}
);
}
async createTaskRunAttempt(runFriendlyId) {
if (!this.accessToken) {
throw new Error("creatTaskRunAttempt: No access token");
}
return wrapZodFetch(TaskRunExecution, `${this.apiURL}/api/v1/runs/${runFriendlyId}/attempts`, {
method: "POST",
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
}
});
}
async getProjectEnv({
projectRef,
env
}) {
if (!this.accessToken) {
throw new Error("getProjectDevEnv: No access token");
}
return wrapZodFetch(
GetProjectEnvResponse,
`${this.apiURL}/api/v1/projects/${projectRef}/${env}`,
{
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
}
}
);
}
async getEnvironmentVariables(projectRef) {
if (!this.accessToken) {
throw new Error("getEnvironmentVariables: No access token");
}
return wrapZodFetch(
GetEnvironmentVariablesResponseBody,
`${this.apiURL}/api/v1/projects/${projectRef}/envvars`,
{
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
}
}
);
}
async importEnvVars(projectRef, slug, params) {
if (!this.accessToken) {
throw new Error("importEnvVars: No access token");
}
return wrapZodFetch(
EnvironmentVariableResponseBody,
`${this.apiURL}/api/v1/projects/${projectRef}/envvars/${slug}/import`,
{
method: "POST",
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
},
body: JSON.stringify(params)
}
);
}
async initializeDeployment(body) {
if (!this.accessToken) {
throw new Error("initializeDeployment: No access token");
}
return wrapZodFetch(InitializeDeploymentResponseBody, `${this.apiURL}/api/v1/deployments`, {
method: "POST",
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
},
body: JSON.stringify(body)
});
}
async startDeploymentIndexing(deploymentId, body) {
if (!this.accessToken) {
throw new Error("startDeploymentIndexing: No access token");
}
return wrapZodFetch(
StartDeploymentIndexingResponseBody,
`${this.apiURL}/api/v1/deployments/${deploymentId}/start-indexing`,
{
method: "POST",
headers: {
Authorization: `Bearer ${this.accessToken}`,
"Content-Type": "application/json"
},
body: JSON.stringify(body)
}
);
}
async getDeployment(deploymentId) {
if (!this.accessToken) {
throw new Error("getDeployment: No access token");
}
return wrapZodFetch(
GetDeploymentResponseBody,
`${this.apiURL}/api/v1/deployments/${deploymentId}`,
{
headers: {
Authorization: `Bearer ${this.accessToken}`,
Accept: "application/json"
}
}
);
}
};
async function wrapZodFetch(schema, url, requestInit) {
try {
const response = await zodfetch(schema, url, requestInit, {
retry: {
minTimeoutInMs: 500,
maxTimeoutInMs: 5e3,
maxAttempts: 3,
factor: 2,
randomize: false
}
});
return {
success: true,
data: response
};
} catch (error) {
if (error instanceof ApiError) {
return {
success: false,
error: error.message
};
} else if (error instanceof Error) {
return {
success: false,
error: error.message
};
} else {
return {
success: false,
error: String(error)
};
}
}
}
// src/cli/common.ts
import { flattenAttributes } from "@systemfsoftware/trigger.dev_core/v3";
import { recordSpanException } from "@systemfsoftware/trigger.dev_core/v3/workers";
import { z } from "zod";
// src/telemetry/tracing.ts
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { Resource, detectResourcesSync, processDetectorSync } from "@opentelemetry/resources";
import { NodeTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node";
import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
import { DiagConsoleLogger, DiagLogLevel, diag, trace } from "@opentelemetry/api";
import {
SEMRESATTRS_SERVICE_NAME,
SEMRESATTRS_SERVICE_VERSION
} from "@opentelemetry/semantic-conventions";
// src/utilities/logger.ts
import { format } from "node:util";
import chalk from "chalk";
import CLITable from "cli-table3";
import { formatMessagesSync } from "esbuild";
// src/utilities/getEnvironmentVariableFactory.ts
function getEnvironmentVariableFactory({
variableName,
deprecatedName,
defaultValue
}) {
let hasWarned = false;
return () => {
if (process.env[variableName]) {
return process.env[variableName];
} else if (deprecatedName && process.env[deprecatedName]) {
if (!hasWarned) {
hasWarned = true;
logger.warn(
`Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
);
}
return process.env[deprecatedName];
} else {
return defaultValue?.();
}
};
}
// src/utilities/logger.ts
var LOGGER_LEVELS = {
none: -1,
error: 0,
warn: 1,
info: 2,
log: 3,
debug: 4
};
var LOGGER_LEVEL_FORMAT_TYPE_MAP = {
error: "error",
warn: "warning",
info: void 0,
log: void 0,
debug: void 0
};
var getLogLevelFromEnv = getEnvironmentVariableFactory({
variableName: "TRIGGER_LOG_LEVEL"
});
function getLoggerLevel() {
const fromEnv = getLogLevelFromEnv()?.toLowerCase();
if (fromEnv !== void 0) {
if (fromEnv in LOGGER_LEVELS)
return fromEnv;
const expected = Object.keys(LOGGER_LEVELS).map((level) => `"${level}"`).join(" | ");
console.warn(
`Unrecognised WRANGLER_LOG value ${JSON.stringify(
fromEnv
)}, expected ${expected}, defaulting to "log"...`
);
}
return "log";
}
var Logger = class {
constructor() {
}
loggerLevel = getLoggerLevel();
columns = process.stdout.columns;
debug = (...args) => this.doLog("debug", args);
ignore = (...args) => {
};
debugWithSanitization = (label, ...args) => {
this.doLog("debug", [label, ...args]);
};
info = (...args) => this.doLog("info", args);
log = (...args) => this.doLog("log", args);
warn = (...args) => this.doLog("warn", args);
error = (...args) => this.doLog("error", args);
table(data, level) {
const keys = data.length === 0 ? [] : Object.keys(data[0]);
const t = new CLITable({
head: keys,
style: {
head: chalk.level ? ["blue"] : [],
border: chalk.level ? ["gray"] : []
}
});
t.push(...data.map((row) => keys.map((k) => row[k])));
return this.doLog(level ?? "log", [t.toString()]);
}
doLog(messageLevel, args) {
const message = this.formatMessage(messageLevel, format(...args));
if (LOGGER_LEVELS[this.loggerLevel] >= LOGGER_LEVELS[messageLevel]) {
console[messageLevel](message);
}
}
formatMessage(level, message) {
const kind = LOGGER_LEVEL_FORMAT_TYPE_MAP[level];
if (kind) {
const [firstLine, ...otherLines] = message.split("\n");
const notes = otherLines.length > 0 ? otherLines.map((text3) => ({ text: text3 })) : void 0;
return formatMessagesSync([{ text: firstLine, notes }], {
color: true,
kind,
terminalWidth: this.columns
})[0];
} else {
return message;
}
}
};
var logger = new Logger();
// src/telemetry/tracing.ts
function initializeTracing() {
if (process.argv.includes("--skip-telemetry") || process.env.TRIGGER_DEV_SKIP_TELEMETRY || // only for backwards compat
process.env.TRIGGER_TELEMETRY_DISABLED) {
logger.debug("\u{1F4C9} Telemetry disabled");
return;
}
if (process.env.OTEL_INTERNAL_DIAG_DEBUG) {
diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);
}
const resource = detectResourcesSync({
detectors: [processDetectorSync]
}).merge(
new Resource({
[SEMRESATTRS_SERVICE_NAME]: "trigger.dev cli v3",
[SEMRESATTRS_SERVICE_VERSION]: version
})
);
const traceProvider = new NodeTracerProvider({
forceFlushTimeoutMillis: 3e4,
resource,
spanLimits: {
attributeCountLimit: 1e3,
attributeValueLengthLimit: 2048,
eventCountLimit: 100,
attributePerEventCountLimit: 100,
linkCountLimit: 10,
attributePerLinkCountLimit: 100
}
});
const spanExporter = new OTLPTraceExporter({
url: "https://otel.baselime.io/v1",
timeoutMillis: 5e3,
headers: {
"x-api-key": "b6e0fbbaf8dc2524773d2152ae2e9eb5c7fbaa52"
}
});
const spanProcessor = new SimpleSpanProcessor(spanExporter);
traceProvider.addSpanProcessor(spanProcessor);
traceProvider.register();
registerInstrumentations({
instrumentations: [new FetchInstrumentation()]
});
return traceProvider;
}
var provider = initializeTracing();
function getTracer() {
return trace.getTracer("trigger.dev cli v3", version);
}
// src/cli/common.ts
import { fromZodError } from "zod-validation-error";
import { outro } from "@clack/prompts";
// src/utilities/cliOutput.ts
import { log } from "@clack/prompts";
import chalk2 from "chalk";
import terminalLink from "terminal-link";
var green = "#4FFF54";
var purple = "#735BF3";
function chalkGreen(text3) {
return chalk2.hex(green)(text3);
}
function chalkPurple(text3) {
return chalk2.hex(purple)(text3);
}
function chalkGrey(text3) {
return chalk2.hex("#878C99")(text3);
}
function chalkError(text3) {
return chalk2.hex("#E11D48")(text3);
}
function chalkWarning(text3) {
return chalk2.yellow(text3);
}
function chalkSuccess(text3) {
return chalk2.hex("#28BF5C")(text3);
}
function chalkLink(text3) {
return chalk2.underline.hex("#D7D9DD")(text3);
}
function chalkWorker(text3) {
return chalk2.hex("#FFFF89")(text3);
}
function chalkTask(text3) {
return chalk2.hex("#60A5FA")(text3);
}
function chalkRun(text3) {
return chalk2.hex("#A78BFA")(text3);
}
function logo() {
return `${chalk2.hex(green).bold("Trigger")}${chalk2.hex(purple).bold(".dev")}`;
}
function prettyPrintDate(date = /* @__PURE__ */ new Date()) {
let formattedDate = new Intl.DateTimeFormat("en-US", {
month: "short",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
second: "2-digit",
hour12: false
}).format(date);
formattedDate += "." + ("00" + date.getMilliseconds()).slice(-3);
return formattedDate;
}
function prettyError(header, body, footer) {
const prefix = "Error: ";
const indent = Array(prefix.length).fill(" ").join("");
const spacing = "\n\n";
const prettyPrefix = chalkError(prefix);
const withIndents = (text3) => text3?.split("\n").map((line) => `${indent}${line}`).join("\n");
const prettyBody = withIndents(body);
const prettyFooter = withIndents(footer);
log.error(
`${prettyPrefix}${header}${prettyBody ? `${spacing}${prettyBody}` : ""}${prettyFooter ? `${spacing}${prettyFooter}` : ""}`
);
}
function prettyWarning(header, body, footer) {
const prefix = "Warning: ";
const indent = Array(prefix.length).fill(" ").join("");
const spacing = "\n\n";
const prettyPrefix = chalkWarning(prefix);
const withIndents = (text3) => text3?.split("\n").map((line) => `${indent}${line}`).join("\n");
const prettyBody = withIndents(body);
const prettyFooter = withIndents(footer);
log.warn(
`${prettyPrefix}${header}${prettyBody ? `${spacing}${prettyBody}` : ""}${prettyFooter ? `${spacing}${prettyFooter}` : ""}`
);
}
function cliLink(text3, url, options) {
return terminalLink(text3, url, {
fallback: (text4, url2) => `${text4} ${url2}`,
...options
});
}
// src/cli/common.ts
var CommonCommandOptions = z.object({
apiUrl: z.string().optional(),
logLevel: z.enum(["debug", "info", "log", "warn", "error", "none"]).default("log"),
skipTelemetry: z.boolean().default(false),
profile: z.string().default("default")
});
function commonOptions(command) {
return command.option("--profile <profile>", "The login profile to use", "default").option("-a, --api-url <value>", "Override the API URL", "https://api.trigger.dev").option(
"-l, --log-level <level>",
"The CLI log level to use (debug, info, log, warn, error, none). This does not effect the log level of your trigger.dev tasks.",
"log"
).option("--skip-telemetry", "Opt-out of sending telemetry");
}
var SkipLoggingError = class extends Error {
};
var SkipCommandError = class extends Error {
};
var OutroCommandError = class extends SkipCommandError {
};
async function handleTelemetry(action) {
try {
await action();
await provider?.forceFlush();
} catch (e) {
await provider?.forceFlush();
process.exitCode = 1;
}
}
var tracer = getTracer();
async function wrapCommandAction(name, schema, options, action) {
return await tracer.startActiveSpan(name, async (span) => {
try {
const parsedOptions = schema.safeParse(options);
if (!parsedOptions.success) {
throw new Error(fromZodError(parsedOptions.error).toString());
}
span.setAttributes({
...flattenAttributes(parsedOptions.data, "cli.options")
});
logger.loggerLevel = parsedOptions.data.logLevel;
logger.debug(`Running "${name}" with the following options`, {
options,
spanContext: span?.spanContext()
});
const result = await action(parsedOptions.data);
span.end();
return result;
} catch (e) {
if (e instanceof SkipLoggingError) {
recordSpanException(span, e);
} else if (e instanceof OutroCommandError) {
outro("Operation cancelled");