@azlib/scheduler 1.0.5 → 1.2.0

package/dist/cli-config-CFBl-YOh.cjs

@@ -0,0 +1,628 @@
+//#region \0rolldown/runtime.js
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_store_dashboard = require("./store-dashboard-Sg4BBWiJ.cjs");
+let _azlib_std = require("@azlib/std");
+let node_http = require("node:http");
+node_http = __toESM(node_http, 1);
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_url = require("node:url");
+let node_async_hooks = require("node:async_hooks");
+let _azlib_persistence = require("@azlib/persistence");
+//#region src/dashboard/http-auth.ts
+var DashboardHttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "DashboardHttpError";
+		this.status = status;
+	}
+};
+function isLoopbackHost(host) {
+	const normalized = host.trim().toLowerCase();
+	return normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1" || normalized === "[::1]";
+}
+function authorizeDashboardRequest(input) {
+	if (!input.token) return;
+	if ((Array.isArray(input.authorization) ? input.authorization[0] : input.authorization) !== `Bearer ${input.token}`) throw new DashboardHttpError(401, "Unauthorized");
+}
+function assertDashboardBindSafety(input) {
+	if (!isLoopbackHost(input.host) && !input.token) throw new Error("DASHBOARD_TOKEN is required when HOST is not a loopback address");
+}
+//#endregion
+//#region src/dashboard/http-parse.ts
+const DEFAULT_TIMEZONE = "UTC";
+function requiredText(value, field) {
+	const text = (0, _azlib_std.asString)(value)?.trim();
+	if (!text) throw new DashboardHttpError(400, `${field} is required.`);
+	return text;
+}
+function parseConfig(value) {
+	if (value === void 0 || value === null || value === "") return {};
+	if (typeof value === "string") try {
+		return JSON.parse(value);
+	} catch {
+		throw new DashboardHttpError(400, "config must be valid JSON.");
+	}
+	return value;
+}
+function parseScheduleFromRecord(record) {
+	const nested = (0, _azlib_std.asRecord)(record.schedule);
+	const scheduleType = (0, _azlib_std.asString)(record.scheduleType)?.trim() || (0, _azlib_std.asString)(nested?.scheduleType)?.trim() || "cron";
+	if (scheduleType !== "cron" && scheduleType !== "once") throw new DashboardHttpError(400, "scheduleType must be cron or once.");
+	const expression = requiredText(record.expression ?? nested?.expression, "expression");
+	const timezone = (0, _azlib_std.asString)(record.timezone)?.trim() || (0, _azlib_std.asString)(nested?.timezone)?.trim() || DEFAULT_TIMEZONE;
+	require_store_dashboard.parseSchedule(scheduleType, expression, timezone);
+	return {
+		scheduleType,
+		expression,
+		timezone
+	};
+}
+function parseCreateJobBody(body) {
+	const record = (0, _azlib_std.asRecord)(body);
+	if (!record) throw new DashboardHttpError(400, "Request body must be a JSON object.");
+	return {
+		name: requiredText(record.name, "name"),
+		handlerKey: requiredText(record.handlerKey, "handlerKey"),
+		schedule: parseScheduleFromRecord(record),
+		config: parseConfig(record.config),
+		enabled: (0, _azlib_std.asBoolean)(record.enabled) ?? true
+	};
+}
+function parseUpdateJobBody(body) {
+	const record = (0, _azlib_std.asRecord)(body);
+	if (!record) throw new DashboardHttpError(400, "Request body must be a JSON object.");
+	const patch = {};
+	if (record.name !== void 0) patch.name = requiredText(record.name, "name");
+	if (record.handlerKey !== void 0) patch.handlerKey = requiredText(record.handlerKey, "handlerKey");
+	if (record.expression !== void 0 || record.timezone !== void 0 || record.scheduleType !== void 0 || record.schedule !== void 0) patch.schedule = parseScheduleFromRecord(record);
+	if (record.config !== void 0) patch.config = parseConfig(record.config);
+	if (record.enabled !== void 0) patch.enabled = (0, _azlib_std.asBoolean)(record.enabled) ?? true;
+	return patch;
+}
+//#endregion
+//#region src/dashboard/http-path.ts
+function normalizeDashboardBasePath(basePath) {
+	const trimmed = basePath?.trim();
+	if (!trimmed || trimmed === "/") return "";
+	return (trimmed.startsWith("/") ? trimmed : `/${trimmed}`).replace(/\/+$/, "");
+}
+function stripDashboardBasePath(pathname, basePath) {
+	const base = normalizeDashboardBasePath(basePath);
+	const path = pathname || "/";
+	if (!base) return path.startsWith("/") ? path : `/${path}`;
+	if (path === base || path === `${base}/`) return "/";
+	if (path.startsWith(`${base}/`)) {
+		const rest = path.slice(base.length);
+		return rest.startsWith("/") ? rest : `/${rest}`;
+	}
+	return null;
+}
+function resolveDashboardApiBase(pathname) {
+	const trimmed = (pathname.split("?")[0] || "/").replace(/\/index\.html$/i, "/").replace(/\/[^/]+\.[a-z0-9]+$/i, "/").replace(/\/+$/, "");
+	return trimmed === "" ? "/api" : `${trimmed}/api`;
+}
+function requestPathname(url, originalUrl) {
+	const raw = originalUrl || url || "/";
+	try {
+		return new URL(raw, "http://127.0.0.1").pathname;
+	} catch {
+		return raw.split("?")[0] || "/";
+	}
+}
+//#endregion
+//#region src/dashboard/public-dir.ts
+function resolveDashboardPublicDir(fromFileUrl) {
+	const dir = (0, node_path.dirname)((0, node_url.fileURLToPath)(fromFileUrl));
+	const nested = (0, node_path.join)(dir, "public");
+	const sibling = (0, node_path.join)(dir, "dashboard", "public");
+	if ((0, node_fs.existsSync)((0, node_path.join)(nested, "index.html"))) return nested;
+	if ((0, node_fs.existsSync)((0, node_path.join)(sibling, "index.html"))) return sibling;
+	return nested;
+}
+//#endregion
+//#region src/dashboard/http-handler.ts
+const MIME_TYPES = {
+	".css": "text/css; charset=utf-8",
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".map": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".woff2": "font/woff2"
+};
+function sendJson(res, status, body) {
+	res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(body));
+}
+function sendDashboardError(res, error) {
+	if (error instanceof DashboardHttpError) {
+		sendJson(res, error.status, { error: error.message });
+		return;
+	}
+	const message = error instanceof Error ? error.message : "Unknown error";
+	sendJson(res, message.includes("not found") ? 404 : message.includes("Only failed") ? 400 : message.includes("Unknown handlerKey") ? 400 : 500, { error: message });
+}
+function hasParsedBody(req) {
+	return Object.prototype.hasOwnProperty.call(req, "body");
+}
+async function readJsonBody(req) {
+	if (req.readableEnded && hasParsedBody(req)) return req.body ?? {};
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	if (chunks.length === 0) {
+		if (hasParsedBody(req)) return req.body ?? {};
+		return {};
+	}
+	const raw = Buffer.concat(chunks).toString("utf8");
+	if (!raw.trim()) return {};
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new DashboardHttpError(400, "Request body must be valid JSON.");
+	}
+}
+function matchPath(pathname, pattern) {
+	const pathParts = pathname.split("/").filter(Boolean);
+	const patternParts = pattern.split("/").filter(Boolean);
+	if (pathParts.length !== patternParts.length) return null;
+	const params = {};
+	for (let i = 0; i < patternParts.length; i += 1) {
+		const expected = patternParts[i] ?? "";
+		const actual = pathParts[i] ?? "";
+		if (expected.startsWith(":")) {
+			params[expected.slice(1)] = decodeURIComponent(actual);
+			continue;
+		}
+		if (expected !== actual) return null;
+	}
+	return params;
+}
+function servePublicFile(publicDir, urlPath, res) {
+	if (!(0, node_fs.existsSync)(publicDir)) return false;
+	const pathname = decodeURIComponent(urlPath.split("?")[0] ?? "/");
+	const abs = (0, node_path.resolve)(publicDir, `.${pathname === "/" ? "/index.html" : pathname}`);
+	const rel = (0, node_path.relative)((0, node_path.resolve)(publicDir), abs);
+	if (rel.startsWith("..") || rel.includes(`..${node_path.sep}`)) return false;
+	const filePath = (0, node_fs.existsSync)(abs) && (0, node_fs.statSync)(abs).isFile() ? abs : (0, node_path.join)(publicDir, "index.html");
+	if (!(0, node_fs.existsSync)(filePath) || !(0, node_fs.statSync)(filePath).isFile()) return false;
+	const type = MIME_TYPES[(0, node_path.extname)(filePath)] ?? "application/octet-stream";
+	res.writeHead(200, { "Content-Type": type });
+	(0, node_fs.createReadStream)(filePath).pipe(res);
+	return true;
+}
+async function authorizeApi(options, method, pathname, req) {
+	if (options.authorize) {
+		await options.authorize({
+			method,
+			pathname,
+			authorization: req.headers.authorization
+		});
+		return;
+	}
+	authorizeDashboardRequest({
+		token: options.token,
+		authorization: req.headers.authorization
+	});
+}
+async function handleApi(dashboard, method, pathname, req, res) {
+	if (method === "GET" && pathname === "/api/health") {
+		sendJson(res, 200, await dashboard.getHealth());
+		return;
+	}
+	if (method === "GET" && pathname === "/api/handlers") {
+		sendJson(res, 200, { handlers: dashboard.listHandlerKeys() });
+		return;
+	}
+	if (method === "GET" && pathname === "/api/jobs") {
+		sendJson(res, 200, { items: await dashboard.listItems() });
+		return;
+	}
+	if (method === "POST" && pathname === "/api/jobs") {
+		sendJson(res, 201, await dashboard.createJob(parseCreateJobBody(await readJsonBody(req))));
+		return;
+	}
+	const jobExec = matchPath(pathname, "/api/jobs/:jobId/executions");
+	if (jobExec && method === "GET") {
+		sendJson(res, 200, { executions: await dashboard.listExecutions(jobExec.jobId ?? "") });
+		return;
+	}
+	const jobAction = matchPath(pathname, "/api/jobs/:jobId/:action");
+	if (jobAction && method === "POST") {
+		const jobId = jobAction.jobId ?? "";
+		if (jobAction.action === "pause") {
+			await dashboard.pauseJob(jobId);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (jobAction.action === "resume") {
+			await dashboard.resumeJob(jobId);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (jobAction.action === "run") {
+			await dashboard.runJob(jobId);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+	}
+	const retry = matchPath(pathname, "/api/executions/:executionId/retry");
+	if (retry && method === "POST") {
+		await dashboard.retryExecution(retry.executionId ?? "");
+		res.writeHead(204);
+		res.end();
+		return;
+	}
+	const job = matchPath(pathname, "/api/jobs/:jobId");
+	if (job) {
+		const jobId = job.jobId ?? "";
+		if (method === "GET") {
+			const item = await dashboard.getJob(jobId);
+			if (!item) throw new DashboardHttpError(404, `Job not found: ${jobId}`);
+			sendJson(res, 200, item);
+			return;
+		}
+		if (method === "PATCH") {
+			await dashboard.updateJob(jobId, parseUpdateJobBody(await readJsonBody(req)));
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (method === "DELETE") {
+			await dashboard.deleteJob(jobId);
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+	}
+	sendJson(res, 404, { error: "Not Found" });
+}
+async function handleSchedulerDashboardRequest(req, res, options) {
+	const method = req.method ?? "GET";
+	const originalUrl = "originalUrl" in req && typeof req.originalUrl === "string" ? req.originalUrl : void 0;
+	const pathname = requestPathname(req.url, originalUrl);
+	const basePath = normalizeDashboardBasePath(options.basePath);
+	const relative = stripDashboardBasePath(pathname, basePath);
+	if (relative === null) return false;
+	if (method === "GET" && basePath && pathname === basePath) {
+		res.writeHead(302, { Location: `${basePath}/` });
+		res.end();
+		return true;
+	}
+	const publicDir = options.publicDir ?? resolveDashboardPublicDir(require("url").pathToFileURL(__filename).href);
+	try {
+		if (method === "GET" && relative === "/health") {
+			res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+			res.end("ok");
+			return true;
+		}
+		if (relative === "/api" || relative.startsWith("/api/")) {
+			await authorizeApi(options, method, relative, req);
+			await handleApi(options.dashboard, method, relative, req, res);
+			return true;
+		}
+		if (method === "GET" && servePublicFile(publicDir, relative, res)) return true;
+		res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+		res.end("Not Found");
+		return true;
+	} catch (error) {
+		sendDashboardError(res, error);
+		return true;
+	}
+}
+function createSchedulerDashboardNodeHandler(options) {
+	return (req, res, next) => {
+		handleSchedulerDashboardRequest(req, res, options).then((handled) => {
+			if (!handled) next?.();
+		}).catch((error) => {
+			if (next) {
+				next(error);
+				return;
+			}
+			if (!res.headersSent) sendDashboardError(res, error);
+		});
+	};
+}
+//#endregion
+//#region src/dashboard/http-server.ts
+function createSchedulerDashboardServer(options) {
+	const port = options.port ?? 9100;
+	const host = options.host ?? "127.0.0.1";
+	const handler = createSchedulerDashboardNodeHandler({
+		...options,
+		publicDir: options.publicDir ?? resolveDashboardPublicDir(require("url").pathToFileURL(__filename).href)
+	});
+	const server = node_http.createServer((req, res) => {
+		handler(req, res, () => {
+			if (!res.headersSent) {
+				res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+				res.end("Not Found");
+			}
+		});
+	});
+	return {
+		get port() {
+			return port;
+		},
+		get host() {
+			return host;
+		},
+		listen() {
+			return new Promise((resolveListen, reject) => {
+				server.once("error", reject);
+				server.listen(port, host, () => {
+					server.off("error", reject);
+					resolveListen();
+				});
+			});
+		},
+		close() {
+			return new Promise((resolveClose, reject) => {
+				server.close((err) => err ? reject(err) : resolveClose());
+			});
+		}
+	};
+}
+//#endregion
+//#region src/dashboard/sql-drivers.ts
+function rewriteQuestionParams(sql, style) {
+	if (style === "?") return sql;
+	let index = 0;
+	return sql.replaceAll("?", () => {
+		index += 1;
+		return style === "$n" ? `$${index}` : `@p${index}`;
+	});
+}
+function inferDashboardDialect(databaseUrl) {
+	const scheme = databaseUrl.split(":")[0]?.toLowerCase() ?? "";
+	if (scheme === "postgres" || scheme === "postgresql") return "postgres";
+	if (scheme === "mysql" || scheme === "mariadb") return "mysql";
+	if (scheme === "mssql" || scheme === "sqlserver") return "mssql";
+	if (scheme === "sqlite" || scheme === "file") return "sqlite";
+	return "postgres";
+}
+function dialectAdapterFor(dialect) {
+	if (dialect === "mysql") return (0, _azlib_persistence.createMySqlDialectAdapter)();
+	if (dialect === "sqlite") return (0, _azlib_persistence.createSqliteDialectAdapter)();
+	if (dialect === "mssql") return (0, _azlib_persistence.createSqlServerDialectAdapter)();
+	return (0, _azlib_persistence.createPostgresDialectAdapter)();
+}
+function sqlitePathFromUrl(databaseUrl) {
+	if (databaseUrl.startsWith("file:")) return databaseUrl.slice(5);
+	if (databaseUrl.startsWith("sqlite:")) return databaseUrl.slice(7);
+	return databaseUrl;
+}
+function bindMssqlParams(request, params) {
+	(params ?? []).forEach((value, index) => {
+		request.input(`p${index + 1}`, value);
+	});
+}
+function createPgDriver(pool) {
+	const txStore = new node_async_hooks.AsyncLocalStorage();
+	const active = () => txStore.getStore() ?? pool;
+	const runQuery = async (sql, params) => active().query(rewriteQuestionParams(sql, "$n"), [...params ?? []]);
+	return {
+		query: async (sql, params) => {
+			return (await runQuery(sql, params)).rows;
+		},
+		execute: async (sql, params) => {
+			await runQuery(sql, params);
+		},
+		transaction: async (run) => {
+			if (txStore.getStore()) return run();
+			const conn = await pool.connect();
+			try {
+				await conn.query("BEGIN");
+				const result = await txStore.run(conn, run);
+				await conn.query("COMMIT");
+				return result;
+			} catch (error) {
+				await conn.query("ROLLBACK");
+				throw error;
+			} finally {
+				conn.release();
+			}
+		}
+	};
+}
+function createMysqlDriver(pool) {
+	const txStore = new node_async_hooks.AsyncLocalStorage();
+	const active = () => txStore.getStore() ?? pool;
+	return {
+		query: async (sql, params) => {
+			const [rows] = await active().execute(sql, [...params ?? []]);
+			return rows;
+		},
+		execute: async (sql, params) => {
+			await active().execute(sql, [...params ?? []]);
+		},
+		transaction: async (run) => {
+			if (txStore.getStore()) return run();
+			const conn = await pool.getConnection();
+			try {
+				await conn.beginTransaction();
+				const result = await txStore.run(conn, run);
+				await conn.commit();
+				return result;
+			} catch (error) {
+				await conn.rollback();
+				throw error;
+			} finally {
+				conn.release();
+			}
+		}
+	};
+}
+async function createDashboardSqlDriver(databaseUrl, dialect) {
+	if (dialect === "postgres") {
+		const pg = await import("pg");
+		const Pool = pg.Pool ?? pg.default?.Pool;
+		if (!Pool) throw new Error("The pg package is required for postgres dashboards.");
+		return createPgDriver(new Pool({ connectionString: databaseUrl }));
+	}
+	if (dialect === "mysql") {
+		const mysql = await import("mysql2/promise");
+		const createPool = mysql.createPool ?? mysql.default?.createPool;
+		if (!createPool) throw new Error("The mysql2 package is required for mysql dashboards.");
+		return createMysqlDriver(createPool(databaseUrl));
+	}
+	if (dialect === "sqlite") {
+		const Database = (await import("better-sqlite3")).default;
+		if (!Database) throw new Error("The better-sqlite3 package is required for sqlite dashboards.");
+		const db = new Database(sqlitePathFromUrl(databaseUrl));
+		return {
+			query: async (sql, params) => db.prepare(sql).all(...params ?? []),
+			execute: async (sql, params) => {
+				db.prepare(sql).run(...params ?? []);
+			},
+			transaction: async (run) => run()
+		};
+	}
+	const mssql = await import("mssql");
+	const connect = mssql.connect ?? mssql.default?.connect;
+	if (!connect) throw new Error("The mssql package is required for mssql dashboards.");
+	const pool = await connect(databaseUrl);
+	return {
+		query: async (sql, params) => {
+			const request = pool.request();
+			bindMssqlParams(request, params);
+			return (await request.query(rewriteQuestionParams(sql, "@pn"))).recordset;
+		},
+		execute: async (sql, params) => {
+			const request = pool.request();
+			bindMssqlParams(request, params);
+			await request.query(rewriteQuestionParams(sql, "@pn"));
+		},
+		transaction: async (run) => run()
+	};
+}
+function createDashboardPersistenceConfig(input) {
+	return {
+		client: (0, _azlib_persistence.createSqlClientAdapter)(input.driver),
+		dialect: dialectAdapterFor(input.dialect),
+		namespace: input.namespace
+	};
+}
+//#endregion
+//#region src/dashboard/cli-config.ts
+function parsePort(value, fallback) {
+	if (!value) return fallback;
+	const port = Number(value);
+	if (!Number.isInteger(port) || port <= 0 || port > 65535) throw new Error(`Invalid PORT: ${value}`);
+	return port;
+}
+function parseDialect(value, databaseUrl) {
+	const explicit = value?.trim().toLowerCase();
+	if (!explicit) return inferDashboardDialect(databaseUrl);
+	if (explicit === "postgres" || explicit === "mysql" || explicit === "sqlite" || explicit === "mssql") return explicit;
+	throw new Error(`Invalid SCHEDULER_DIALECT: ${value}. Use postgres, mysql, sqlite, or mssql.`);
+}
+function parseDashboardCliEnv(env) {
+	const databaseUrl = (0, _azlib_std.asString)(env.DATABASE_URL)?.trim();
+	if (!databaseUrl) throw new Error("DATABASE_URL is required");
+	const host = (0, _azlib_std.asString)(env.HOST)?.trim() || "127.0.0.1";
+	const token = (0, _azlib_std.asString)(env.DASHBOARD_TOKEN)?.trim() || void 0;
+	assertDashboardBindSafety({
+		host,
+		token
+	});
+	return {
+		databaseUrl,
+		dialect: parseDialect(env.SCHEDULER_DIALECT, databaseUrl),
+		namespace: (0, _azlib_std.asString)(env.SCHEDULER_NAMESPACE)?.trim() || "azlib",
+		port: parsePort(env.PORT, 9100),
+		host,
+		token
+	};
+}
+//#endregion
+Object.defineProperty(exports, "DashboardHttpError", {
+	enumerable: true,
+	get: function() {
+		return DashboardHttpError;
+	}
+});
+Object.defineProperty(exports, "createDashboardPersistenceConfig", {
+	enumerable: true,
+	get: function() {
+		return createDashboardPersistenceConfig;
+	}
+});
+Object.defineProperty(exports, "createDashboardSqlDriver", {
+	enumerable: true,
+	get: function() {
+		return createDashboardSqlDriver;
+	}
+});
+Object.defineProperty(exports, "createSchedulerDashboardNodeHandler", {
+	enumerable: true,
+	get: function() {
+		return createSchedulerDashboardNodeHandler;
+	}
+});
+Object.defineProperty(exports, "createSchedulerDashboardServer", {
+	enumerable: true,
+	get: function() {
+		return createSchedulerDashboardServer;
+	}
+});
+Object.defineProperty(exports, "handleSchedulerDashboardRequest", {
+	enumerable: true,
+	get: function() {
+		return handleSchedulerDashboardRequest;
+	}
+});
+Object.defineProperty(exports, "normalizeDashboardBasePath", {
+	enumerable: true,
+	get: function() {
+		return normalizeDashboardBasePath;
+	}
+});
+Object.defineProperty(exports, "parseDashboardCliEnv", {
+	enumerable: true,
+	get: function() {
+		return parseDashboardCliEnv;
+	}
+});
+Object.defineProperty(exports, "resolveDashboardApiBase", {
+	enumerable: true,
+	get: function() {
+		return resolveDashboardApiBase;
+	}
+});
+Object.defineProperty(exports, "resolveDashboardPublicDir", {
+	enumerable: true,
+	get: function() {
+		return resolveDashboardPublicDir;
+	}
+});
+Object.defineProperty(exports, "stripDashboardBasePath", {
+	enumerable: true,
+	get: function() {
+		return stripDashboardBasePath;
+	}
+});

package/dist/dashboard/cli.cjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_cli_config = require("../cli-config-CFBl-YOh.cjs");
+const require_store_dashboard = require("../store-dashboard-Sg4BBWiJ.cjs");
+let node_url = require("node:url");
+//#region src/dashboard/cli.ts
+async function startSchedulerDashboardCli(env = process.env) {
+	const config = require_cli_config.parseDashboardCliEnv(env);
+	const server = require_cli_config.createSchedulerDashboardServer({
+		dashboard: require_store_dashboard.createSchedulerDashboardFromPersistence(require_cli_config.createDashboardPersistenceConfig({
+			driver: await require_cli_config.createDashboardSqlDriver(config.databaseUrl, config.dialect),
+			dialect: config.dialect,
+			namespace: config.namespace
+		})),
+		port: config.port,
+		host: config.host,
+		token: config.token,
+		publicDir: require_cli_config.resolveDashboardPublicDir(require("url").pathToFileURL(__filename).href)
+	});
+	await server.listen();
+	process.stderr.write(`@azlib/scheduler dashboard listening on http://${config.host}:${config.port}\n`);
+	return server;
+}
+if (Boolean(process.argv[1]) && require("url").pathToFileURL(__filename).href === (0, node_url.pathToFileURL)(process.argv[1]).href) startSchedulerDashboardCli().catch((error) => {
+	const message = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`${message}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+exports.startSchedulerDashboardCli = startSchedulerDashboardCli;

package/dist/dashboard/cli.d.cts

@@ -0,0 +1,6 @@
+import { t as SchedulerDashboardServer } from "../http-server-u1BnbkAK.cjs";
+//#region src/dashboard/cli.d.ts
+declare function startSchedulerDashboardCli(env?: Record<string, string | undefined>): Promise<SchedulerDashboardServer>;
+//#endregion
+export { startSchedulerDashboardCli };
+//# sourceMappingURL=cli.d.cts.map

package/dist/dashboard/cli.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.cts","names":[],"sources":["../../src/dashboard/cli.ts"],"mappings":";;iBAasB,2BACpB,MAAK,qCAAgD,QAAhD"}

package/dist/dashboard/cli.d.mts

@@ -0,0 +1,6 @@
+import { t as SchedulerDashboardServer } from "../http-server-Cme4XKyH.mjs";
+//#region src/dashboard/cli.d.ts
+declare function startSchedulerDashboardCli(env?: Record<string, string | undefined>): Promise<SchedulerDashboardServer>;
+//#endregion
+export { startSchedulerDashboardCli };
+//# sourceMappingURL=cli.d.mts.map

package/dist/dashboard/cli.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.mts","names":[],"sources":["../../src/dashboard/cli.ts"],"mappings":";;iBAasB,2BACpB,MAAK,qCAAgD,QAAhD"}