@azlib/scheduler 1.0.5 → 1.2.0

package/Dockerfile

@@ -0,0 +1,14 @@
+FROM node:22-alpine
+
+WORKDIR /app
+
+RUN npm install --omit=dev @azlib/scheduler pg
+
+ENV HOST=0.0.0.0
+ENV PORT=9100
+ENV SCHEDULER_DIALECT=postgres
+ENV SCHEDULER_NAMESPACE=azlib
+
+EXPOSE 9100
+
+CMD ["node", "node_modules/@azlib/scheduler/dist/dashboard/cli.mjs"]

package/README.md

@@ -11,6 +11,7 @@ Cron-style job scheduler for Node.js, supporting timezone normalization, overlap
 - Queue-backed execution dispatch through `@azlib/queue`
 - Cache coordination using `@azlib/cache`
 - Structured database state persistence (SQL persistence)
+- Operator dashboard (HTTP + React UI) for monitoring and controlling jobs
 
 ## AI Agent Quick Reference
 
@@ -22,6 +23,58 @@ Cron-style job scheduler for Node.js, supporting timezone normalization, overlap
 | `createCronExpression(): CronExpressionBuilder`                                 | Function | Fluent helper to construct standard 5-field cron strings.                 |
 | `bindSchedulerToHost(service: SchedulerService, adapter: SchedulerHostAdapter)` | Function | Automatically starts/stops the scheduler based on custom server bindings. |
 | `CronWeekday`                                                                   | Enum     | Monday through Sunday utility enum values.                                |
+| `createSchedulerDashboardService(scheduler, options?)`                          | Function | Operator API: health, list, pause/resume, run-now, retry, CRUD.           |
+| `createSchedulerDashboardFromPersistence(persistence)`                          | Function | Sidecar dashboard against the same SQL tables (does not start the engine). |
+| `createSchedulerDashboardServer(options)`                                       | Function | Serves the React UI and JSON API (`@azlib/scheduler/dashboard`).          |
+| `createSchedulerDashboardNodeHandler(options)`                                  | Function | Same monitor as the standalone server, for Express/`http` hosts.          |
+
+### Dashboard
+
+The dashboard can run **in-process** next to a live `SchedulerService`, or as a **sidecar / Docker** process that shares SQL persistence. The sidecar never starts a second scheduler engine. Pause/resume writes `enabled` on the job row; the worker re-reads that on every tick.
+
+```ts
+import {
+  createSchedulerDashboardServer,
+  createSchedulerDashboardService,
+  createSchedulerDashboardNodeHandler,
+} from "@azlib/scheduler/dashboard";
+
+const dashboard = createSchedulerDashboardService(service, { handlers });
+const server = createSchedulerDashboardServer({
+  dashboard,
+  port: 9100,
+  host: "127.0.0.1",
+});
+await server.listen();
+
+// Or mount the same monitor on an existing Node/Express server:
+app.use(
+  createSchedulerDashboardNodeHandler({
+    dashboard,
+    basePath: "/scheduler",
+    authorize: async ({ authorization }) => {
+      // throw DashboardHttpError(401 | 403, message) to reject
+    },
+  }),
+);
+```
+
+Sidecar CLI (`azlib-scheduler-dashboard`) and Docker (`packages/scheduler/Dockerfile`, `compose.yaml`):
+
+| Env | Default | Notes |
+| --- | --- | --- |
+| `DATABASE_URL` | required | Same database as the worker |
+| `SCHEDULER_DIALECT` | inferred from URL | `postgres` (default), `mysql`, `sqlite`, `mssql` |
+| `SCHEDULER_NAMESPACE` | `azlib` | Table prefix (`azlib__scheduler_jobs`, …) |
+| `HOST` | `127.0.0.1` | Use `0.0.0.0` in Docker |
+| `PORT` | `9100` | |
+| `DASHBOARD_TOKEN` | required when HOST is not loopback | `Authorization: Bearer …` on `/api/*` |
+
+Install the matching SQL driver (`pg`, `mysql2`, `better-sqlite3`, or `mssql`) next to `@azlib/scheduler`. Run-now and retry enqueue only when the worker’s queue is reachable; pause, resume, update, and delete work from SQL alone.
+
+```bash
+DASHBOARD_TOKEN=secret docker compose -f packages/scheduler/compose.yaml up --build
+```
 
 ### Core Types & Signatures
 

package/compose.yaml

@@ -0,0 +1,28 @@
+services:
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_DB: scheduler
+      POSTGRES_PASSWORD: scheduler
+    ports:
+      - "5432:5432"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d scheduler"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  scheduler-dashboard:
+    build: .
+    ports:
+      - "9100:9100"
+    environment:
+      DATABASE_URL: postgres://postgres:scheduler@postgres:5432/scheduler
+      SCHEDULER_DIALECT: postgres
+      SCHEDULER_NAMESPACE: azlib
+      HOST: 0.0.0.0
+      PORT: "9100"
+      DASHBOARD_TOKEN: ${DASHBOARD_TOKEN}
+    depends_on:
+      postgres:
+        condition: service_healthy

package/dist/cli-config-6u8AzSdw.mjs

@@ -0,0 +1,542 @@
+import { s as parseSchedule } from "./store-dashboard-Cyf_JILa.mjs";
+import { asBoolean, asRecord, asString } from "@azlib/std";
+import * as http from "node:http";
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createMySqlDialectAdapter, createPostgresDialectAdapter, createSqlClientAdapter, createSqlServerDialectAdapter, createSqliteDialectAdapter } from "@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 = 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 = asRecord(record.schedule);
+	const scheduleType = asString(record.scheduleType)?.trim() || 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 = asString(record.timezone)?.trim() || asString(nested?.timezone)?.trim() || DEFAULT_TIMEZONE;
+	parseSchedule(scheduleType, expression, timezone);
+	return {
+		scheduleType,
+		expression,
+		timezone
+	};
+}
+function parseCreateJobBody(body) {
+	const record = 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: asBoolean(record.enabled) ?? true
+	};
+}
+function parseUpdateJobBody(body) {
+	const record = 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 = 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 = dirname(fileURLToPath(fromFileUrl));
+	const nested = join(dir, "public");
+	const sibling = join(dir, "dashboard", "public");
+	if (existsSync(join(nested, "index.html"))) return nested;
+	if (existsSync(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 (!existsSync(publicDir)) return false;
+	const pathname = decodeURIComponent(urlPath.split("?")[0] ?? "/");
+	const abs = resolve(publicDir, `.${pathname === "/" ? "/index.html" : pathname}`);
+	const rel = relative(resolve(publicDir), abs);
+	if (rel.startsWith("..") || rel.includes(`..${sep}`)) return false;
+	const filePath = existsSync(abs) && statSync(abs).isFile() ? abs : join(publicDir, "index.html");
+	if (!existsSync(filePath) || !statSync(filePath).isFile()) return false;
+	const type = MIME_TYPES[extname(filePath)] ?? "application/octet-stream";
+	res.writeHead(200, { "Content-Type": type });
+	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(import.meta.url);
+	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(import.meta.url)
+	});
+	const server = 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 createMySqlDialectAdapter();
+	if (dialect === "sqlite") return createSqliteDialectAdapter();
+	if (dialect === "mssql") return createSqlServerDialectAdapter();
+	return 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 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 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: 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 = asString(env.DATABASE_URL)?.trim();
+	if (!databaseUrl) throw new Error("DATABASE_URL is required");
+	const host = asString(env.HOST)?.trim() || "127.0.0.1";
+	const token = asString(env.DASHBOARD_TOKEN)?.trim() || void 0;
+	assertDashboardBindSafety({
+		host,
+		token
+	});
+	return {
+		databaseUrl,
+		dialect: parseDialect(env.SCHEDULER_DIALECT, databaseUrl),
+		namespace: asString(env.SCHEDULER_NAMESPACE)?.trim() || "azlib",
+		port: parsePort(env.PORT, 9100),
+		host,
+		token
+	};
+}
+//#endregion
+export { createSchedulerDashboardNodeHandler as a, normalizeDashboardBasePath as c, DashboardHttpError as d, createSchedulerDashboardServer as i, resolveDashboardApiBase as l, createDashboardPersistenceConfig as n, handleSchedulerDashboardRequest as o, createDashboardSqlDriver as r, resolveDashboardPublicDir as s, parseDashboardCliEnv as t, stripDashboardBasePath as u };
+
+//# sourceMappingURL=cli-config-6u8AzSdw.mjs.map