@azlib/scheduler 1.0.4 → 1.1.0

package/dist/cli-config-Cz8QP_4I.cjs

@@ -0,0 +1,512 @@
+//#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_fs = require("node:fs");
+let node_http = require("node:http");
+node_http = __toESM(node_http, 1);
+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/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-server.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 sendError(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 });
+}
+async function readJsonBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	if (chunks.length === 0) 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;
+}
+function createSchedulerDashboardServer(options) {
+	const port = options.port ?? 9100;
+	const host = options.host ?? "127.0.0.1";
+	const publicDir = options.publicDir ?? resolveDashboardPublicDir(require("url").pathToFileURL(__filename).href);
+	const dashboard = options.dashboard;
+	const server = node_http.createServer((req, res) => {
+		handleRequest(req, res).catch((error) => {
+			if (!res.headersSent) sendError(res, error);
+		});
+	});
+	async function handleRequest(req, res) {
+		const method = req.method ?? "GET";
+		const pathname = new URL(req.url ?? "/", `http://${host}:${port}`).pathname;
+		if (method === "GET" && pathname === "/health") {
+			res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+			res.end("ok");
+			return;
+		}
+		if (pathname === "/api" || pathname.startsWith("/api/")) {
+			authorizeDashboardRequest({
+				token: options.token,
+				authorization: req.headers.authorization
+			});
+			await handleApi(method, pathname, req, res);
+			return;
+		}
+		if (method === "GET" && servePublicFile(publicDir, pathname, res)) return;
+		res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+		res.end("Not Found");
+	}
+	async function handleApi(method, pathname, req, res) {
+		try {
+			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" });
+		} catch (error) {
+			sendError(res, error);
+		}
+	}
+	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, "createDashboardPersistenceConfig", {
+	enumerable: true,
+	get: function() {
+		return createDashboardPersistenceConfig;
+	}
+});
+Object.defineProperty(exports, "createDashboardSqlDriver", {
+	enumerable: true,
+	get: function() {
+		return createDashboardSqlDriver;
+	}
+});
+Object.defineProperty(exports, "createSchedulerDashboardServer", {
+	enumerable: true,
+	get: function() {
+		return createSchedulerDashboardServer;
+	}
+});
+Object.defineProperty(exports, "parseDashboardCliEnv", {
+	enumerable: true,
+	get: function() {
+		return parseDashboardCliEnv;
+	}
+});
+Object.defineProperty(exports, "resolveDashboardPublicDir", {
+	enumerable: true,
+	get: function() {
+		return resolveDashboardPublicDir;
+	}
+});

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-Cz8QP_4I.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-DN6Lg464.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-DPQ9HIK-.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"}

package/dist/dashboard/cli.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { t as createSchedulerDashboardFromPersistence } from "../store-dashboard-Cyf_JILa.mjs";
+import { a as resolveDashboardPublicDir, i as createSchedulerDashboardServer, n as createDashboardPersistenceConfig, r as createDashboardSqlDriver, t as parseDashboardCliEnv } from "../cli-config-7F2U8qPM.mjs";
+import { pathToFileURL } from "node:url";
+//#region src/dashboard/cli.ts
+async function startSchedulerDashboardCli(env = process.env) {
+	const config = parseDashboardCliEnv(env);
+	const server = createSchedulerDashboardServer({
+		dashboard: createSchedulerDashboardFromPersistence(createDashboardPersistenceConfig({
+			driver: await createDashboardSqlDriver(config.databaseUrl, config.dialect),
+			dialect: config.dialect,
+			namespace: config.namespace
+		})),
+		port: config.port,
+		host: config.host,
+		token: config.token,
+		publicDir: resolveDashboardPublicDir(import.meta.url)
+	});
+	await server.listen();
+	process.stderr.write(`@azlib/scheduler dashboard listening on http://${config.host}:${config.port}\n`);
+	return server;
+}
+if (Boolean(process.argv[1]) && import.meta.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
+export { startSchedulerDashboardCli };
+
+//# sourceMappingURL=cli.mjs.map

package/dist/dashboard/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../../src/dashboard/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { pathToFileURL } from \"node:url\";\n\nimport { parseDashboardCliEnv } from \"./cli-config.js\";\nimport { createSchedulerDashboardServer } from \"./http-server.js\";\nimport { resolveDashboardPublicDir } from \"./public-dir.js\";\nimport {\n  createDashboardPersistenceConfig,\n  createDashboardSqlDriver,\n} from \"./sql-drivers.js\";\nimport { createSchedulerDashboardFromPersistence } from \"./store-dashboard.js\";\n\nexport async function startSchedulerDashboardCli(\n  env: Record<string, string | undefined> = process.env,\n) {\n  const config = parseDashboardCliEnv(env);\n  const driver = await createDashboardSqlDriver(\n    config.databaseUrl,\n    config.dialect,\n  );\n  const persistence = createDashboardPersistenceConfig({\n    driver,\n    dialect: config.dialect,\n    namespace: config.namespace,\n  });\n  const dashboard = createSchedulerDashboardFromPersistence(persistence);\n  const server = createSchedulerDashboardServer({\n    dashboard,\n    port: config.port,\n    host: config.host,\n    token: config.token,\n    publicDir: resolveDashboardPublicDir(import.meta.url),\n  });\n  await server.listen();\n  process.stderr.write(\n    `@azlib/scheduler dashboard listening on http://${config.host}:${config.port}\\n`,\n  );\n  return server;\n}\n\nconst isDirectRun =\n  Boolean(process.argv[1]) &&\n  import.meta.url === pathToFileURL(process.argv[1]).href;\nif (isDirectRun) {\n  void startSchedulerDashboardCli().catch((error: unknown) => {\n    const message = error instanceof Error ? error.message : String(error);\n    process.stderr.write(`${message}\\n`);\n    process.exitCode = 1;\n  });\n}\n"],"mappings":";;;;;AAaA,eAAsB,2BACpB,MAA0C,QAAQ,KAClD;CACA,MAAM,SAAS,qBAAqB,GAAG;CAWvC,MAAM,SAAS,+BAA+B;EAC5C,WAFgB,wCALE,iCAAiC;GACnD,QAAA,MALmB,yBACnB,OAAO,aACP,OAAO,OACT;GAGE,SAAS,OAAO;GAChB,WAAW,OAAO;EACpB,CACoE,CAE1D;EACR,MAAM,OAAO;EACb,MAAM,OAAO;EACb,OAAO,OAAO;EACd,WAAW,0BAA0B,OAAO,KAAK,GAAG;CACtD,CAAC;CACD,MAAM,OAAO,OAAO;CACpB,QAAQ,OAAO,MACb,kDAAkD,OAAO,KAAK,GAAG,OAAO,KAAK,GAC/E;CACA,OAAO;AACT;AAKA,IAFE,QAAQ,QAAQ,KAAK,EAAE,KACvB,OAAO,KAAK,QAAQ,cAAc,QAAQ,KAAK,EAAE,CAAC,CAAC,MAEnD,2BAAgC,CAAC,CAAC,OAAO,UAAmB;CAC1D,MAAM,UAAU,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;CACrE,QAAQ,OAAO,MAAM,GAAG,QAAQ,GAAG;CACnC,QAAQ,WAAW;AACrB,CAAC"}