@ariestools/cli 0.1.20 → 0.1.22

package/dist/node/datalake.mjs

@@ -1,6 +1,14 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { chmodSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { homedir } from "node:os";
+import os, { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import HTTP from "node:http";
+import HTTPS from "node:https";
+import PROCESS from "node:process";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import tty from "node:tty";
 //#region ../datalake-core/dist/browser/browser.mjs
 var DatalakeApiError = class extends Error {
 	code;
@@ -55,20 +63,20 @@ function datalakePlaneClearPath(id) {
 function datalakePlaneUsagePath(id) {
 	return `${datalakePlaneResourcePath(id)}/usage`;
 }
-var DATALAKE_CONTROL_OPERATIONS = [
+var DATALAKE_CONTROL_OPERATIONS$1 = [
 	"datalake:create",
 	"datalake:describe",
 	"datalake:list"
 ];
-var DATALAKE_DATA_OPERATIONS = [
+var DATALAKE_DATA_OPERATIONS$1 = [
 	"payload:append",
 	"payload:read",
 	"usage:read"
 ];
-DATALAKE_CONTROL_OPERATIONS.join(" ");
-DATALAKE_DATA_OPERATIONS.join(" ");
+DATALAKE_CONTROL_OPERATIONS$1.join(" ");
+DATALAKE_DATA_OPERATIONS$1.join(" ");
 //#endregion
-//#region ../../node_modules/.pnpm/@ariestools+sdk@8.2.0_@opentelemetry+api@1.9.1_zod@4.5.1/node_modules/@ariestools/sdk/dist/neutral/fetch.mjs
+//#region ../../node_modules/.pnpm/@ariestools+sdk@8.3.0_@opentelemetry+api@1.9.1_zod@4.6.1/node_modules/@ariestools/sdk/dist/neutral/fetch.mjs
 var fetchErrorMarker = "$$xylabs-fetch-error";
 var codeTypes = {
 	ENOTFOUND: "dns",
@@ -666,10 +674,11 @@ var LocalDatalakeClient = class {
 		const store = readStore();
 		const datalake = requireDatalake(store, request.datalakeId);
 		const existing = datalake.acl.findIndex((entry2) => entry2.principal === request.principal);
+		const grantedAtDate = /* @__PURE__ */ new Date();
 		const entry = {
 			principal: request.principal,
 			role: request.role,
-			grantedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			grantedAt: grantedAtDate.toISOString(),
 			grantedBy: LOCAL_OWNER_ID
 		};
 		if (existing === -1) datalake.acl.push(entry);
@@ -684,15 +693,17 @@ var LocalDatalakeClient = class {
 	async mintToken(request) {
 		const datalake = requireDatalake(readStore(), request.datalakeId);
 		const ttl = request.ttlSeconds ?? 3600;
+		const issued = Buffer.from(JSON.stringify({
+			dl: datalake.id,
+			role: request.role,
+			exp: Math.floor(Date.now() / 1e3) + ttl
+		})).toString("base64url");
+		const expiresAtDate = new Date(Date.now() + ttl * 1e3);
 		return {
-			token: `local.${Buffer.from(JSON.stringify({
-				dl: datalake.id,
-				role: request.role,
-				exp: Math.floor(Date.now() / 1e3) + ttl
-			})).toString("base64url")}`,
+			token: `local.${issued}`,
 			datalakeId: datalake.id,
 			role: request.role,
-			expiresAt: new Date(Date.now() + ttl * 1e3).toISOString(),
+			expiresAt: expiresAtDate.toISOString(),
 			url: datalake.url ?? `http://localhost:8080/datalakes/${datalake.name}`
 		};
 	}
@@ -949,7 +960,7 @@ var RestPayloadsClient = class {
 };
 function readInsertSummary(headers) {
 	const duplicatesRaw = headers.get(DATALAKE_HEADER_DUPLICATES);
-	const duplicates = duplicatesRaw === null ? 0 : Number.parseInt(duplicatesRaw, 10);
+	const duplicates = duplicatesRaw === null ? 0 : Math.trunc(Number(duplicatesRaw));
 	const rejectedRaw = headers.get(DATALAKE_HEADER_REJECTED);
 	const rejected = rejectedRaw === null || rejectedRaw.length === 0 ? [] : rejectedRaw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
 	return {
@@ -958,4 +969,1006 @@ function readInsertSummary(headers) {
 	};
 }
 //#endregion
-export { LocalDatalakeClient, RestDatalakeClient, RestPayloadsClient, clearCredentials, clearDefaultDatalake, createDatalakeClient, getCredentialsLocation, getDefaultDatalake, loadCredentials, saveCredentials, setDefaultDatalake };
+//#region ../../node_modules/.pnpm/@ariestools+cli-kit-daemon@1.2.3_@ariestools+actor-model@1.3.0_@ariestools+sdk@8.3.0_@o_8cda624dab9c79c693e4473e20d01110/node_modules/@ariestools/cli-kit-daemon/dist/node/index.mjs
+function isProcessAlive(pid) {
+	try {
+		PROCESS.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+var require2 = createRequire(import.meta.url);
+var HEALTH_POLL_MS = 100;
+var STATUS_PING_TIMEOUT_MS = 1e3;
+var DEFAULT_DOWN_GRACE_MS = 2e3;
+var DOWN_POLL_MS = 50;
+var DEFAULT_LOG_LINES = 50;
+var STATUS_LABEL_WIDTH = 10;
+var DAEMON_STATUS_EXIT_CODES = {
+	/** Running and answering health probes. */
+	healthy: 0,
+	/** No live process for the recorded pid, or no state at all. */
+	notRunning: 3,
+	/** Process is alive but not answering health probes. */
+	unresponsive: 2
+};
+var IDENTITY = (text) => text;
+function resolveStyle(style) {
+	return {
+		dim: style?.dim ?? IDENTITY,
+		error: style?.error ?? IDENTITY,
+		info: style?.info ?? IDENTITY,
+		success: style?.success ?? IDENTITY,
+		warn: style?.warn ?? IDENTITY
+	};
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatUptime(startedAt, now) {
+	const started = new Date(startedAt).getTime();
+	if (Number.isNaN(started)) return "";
+	const seconds = Math.max(0, Math.floor((now - started) / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function createDaemonKit$1(config) {
+	const displayName = config.displayName;
+	const capitalizedName = displayName.charAt(0).toUpperCase() + displayName.slice(1);
+	const style = resolveStyle(config.style);
+	const io = config.host.io;
+	const paths = {
+		dir: () => path.join(config.homeDir(), config.dirName),
+		logPath: () => path.join(paths.dir(), "server.log"),
+		pidPath: () => path.join(paths.dir(), "pid"),
+		statePath: () => path.join(paths.dir(), "state.json")
+	};
+	function readState() {
+		const filePath = paths.statePath();
+		if (!existsSync(filePath)) return void 0;
+		let parsed;
+		try {
+			parsed = JSON.parse(readFileSync(filePath, "utf8"));
+		} catch {
+			return;
+		}
+		if (config.normalizeState === void 0) return parsed;
+		const normalized = config.normalizeState(parsed);
+		if (normalized === void 0) return void 0;
+		if (JSON.stringify(parsed) !== JSON.stringify(normalized)) writeState(normalized);
+		return normalized;
+	}
+	function writeState(state) {
+		const dir = paths.dir();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const statePath = paths.statePath();
+		const temporaryStatePath = `${statePath}.${PROCESS.pid}.tmp`;
+		writeFileSync(temporaryStatePath, JSON.stringify(state, void 0, 2), "utf8");
+		renameSync(temporaryStatePath, statePath);
+		writeFileSync(paths.pidPath(), String(state.pid), "utf8");
+	}
+	function clearState() {
+		for (const filePath of [paths.statePath(), paths.pidPath()]) if (existsSync(filePath)) unlinkSync(filePath);
+	}
+	function resolveServerBin() {
+		const { bin } = config;
+		if (bin.embeddedRelPath !== void 0 && bin.embeddedRelPath.length > 0 && bin.resolveFromUrl !== void 0 && bin.resolveFromUrl.length > 0) {
+			const relativeSegments = bin.embeddedRelPath.split("/");
+			const binDir = path.dirname(fileURLToPath(bin.resolveFromUrl));
+			const embedded = path.join(binDir, ...relativeSegments);
+			if (existsSync(embedded)) return embedded;
+			const searchPaths = bin.searchPaths ?? [];
+			for (const searchPath of searchPaths) {
+				const candidate = path.resolve(binDir, searchPath, ...relativeSegments);
+				if (existsSync(candidate)) return candidate;
+			}
+		}
+		if (bin.packageName !== void 0 && bin.binRelPath !== void 0) try {
+			const packageJsonPath = require2.resolve(`${bin.packageName}/package.json`);
+			const binPath = path.join(path.dirname(packageJsonPath), ...bin.binRelPath.split("/"));
+			if (existsSync(binPath)) return binPath;
+		} catch {}
+		throw new Error(`${capitalizedName} binary not found. ${bin.installHint} (expected an embedded daemon beside the calling bin or a resolvable package bin)`);
+	}
+	function probeUrl(baseUrl) {
+		return `${baseUrl.replace(/\/$/, "")}${config.health?.path ?? ""}`;
+	}
+	async function probeOnce(baseUrl, timeoutMs, tlsCa) {
+		return await new Promise((resolve) => {
+			const url = new URL(probeUrl(baseUrl));
+			const request = (url.protocol === "https:" ? HTTPS : HTTP).get(url, { ca: tlsCa }, (response) => {
+				response.resume();
+				const status2 = response.statusCode ?? 0;
+				resolve(config.health?.anyResponse === true || status2 >= 200 && status2 < 300);
+			});
+			request.on("error", () => resolve(false));
+			if (timeoutMs !== void 0) request.setTimeout(timeoutMs, () => {
+				request.destroy();
+				resolve(false);
+			});
+		});
+	}
+	async function waitForHealth(baseUrl, timeoutMs, tlsCa) {
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			if (await probeOnce(baseUrl, void 0, tlsCa)) return true;
+			await delay(HEALTH_POLL_MS);
+		}
+		return false;
+	}
+	async function up(buildSpec) {
+		const existing = readState();
+		if (existing && isProcessAlive(existing.pid)) {
+			io.log(style.warn(`${displayName} already running (pid ${existing.pid}) at ${config.baseUrl(existing)}`));
+			return existing;
+		}
+		if (existing) clearState();
+		const spec = await buildSpec();
+		const binPath = resolveServerBin();
+		const dir = paths.dir();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const logFd = openSync(paths.logPath(), "a");
+		const child = spawn(PROCESS.execPath, [binPath, ...spec.args ?? []], {
+			detached: true,
+			env: spec.env,
+			stdio: [
+				"ignore",
+				logFd,
+				logFd
+			]
+		});
+		child.unref();
+		if (child.pid === void 0) throw new Error(`Failed to spawn ${displayName} process`);
+		io.log(style.dim(`starting ${displayName} (pid ${child.pid})...`));
+		if (!await waitForHealth(spec.healthUrl, spec.timeoutMs, spec.healthTlsCa)) {
+			try {
+				PROCESS.kill(child.pid, "SIGTERM");
+			} catch {}
+			throw new Error(`${capitalizedName} did not become healthy within ${spec.timeoutMs / 1e3}s. Check logs at ${paths.logPath()}`);
+		}
+		const state = spec.buildState(child.pid);
+		writeState(state);
+		spec.onReady?.(state);
+		return state;
+	}
+	async function down(options = {}) {
+		const state = readState();
+		if (!state) {
+			io.log(style.warn(`${displayName} is not running`));
+			return;
+		}
+		const graceMs = options.gracePeriodMs ?? DEFAULT_DOWN_GRACE_MS;
+		const stopped = state;
+		function cleanup() {
+			config.postDown?.(stopped);
+			clearState();
+		}
+		if (!isProcessAlive(state.pid)) {
+			cleanup();
+			io.log(style.success(`${displayName} pid ${state.pid} was already stopped \u2014 cleaned up state`));
+			return;
+		}
+		try {
+			PROCESS.kill(state.pid, "SIGTERM");
+		} catch (error) {
+			if (error.code !== "ESRCH") throw error;
+		}
+		const deadline = Date.now() + graceMs;
+		while (Date.now() < deadline && isProcessAlive(state.pid)) await delay(DOWN_POLL_MS);
+		if (isProcessAlive(state.pid)) try {
+			PROCESS.kill(state.pid, "SIGKILL");
+		} catch {}
+		cleanup();
+		io.log(style.success(`${displayName} pid ${state.pid} stopped`));
+	}
+	function printField(label, value) {
+		io.log(`  ${style.dim(`${label}:`.padEnd(STATUS_LABEL_WIDTH))}${value}`);
+	}
+	function statusLabel(isAlive, isHealthy) {
+		if (isAlive && isHealthy) return style.success("running + healthy");
+		if (isAlive) return style.warn("running but unresponsive");
+		return style.error("stale state (process gone)");
+	}
+	async function status() {
+		const state = readState();
+		if (!state) {
+			io.log(style.warn(`${displayName} not running`));
+			return {
+				exitCode: DAEMON_STATUS_EXIT_CODES.notRunning,
+				isAlive: false,
+				isHealthy: false
+			};
+		}
+		const isAlive = isProcessAlive(state.pid);
+		const tlsCa = config.health?.tlsCa?.(state);
+		const isHealthy = isAlive ? await probeOnce(config.baseUrl(state), STATUS_PING_TIMEOUT_MS, tlsCa) : false;
+		const uptime = formatUptime(state.startedAt, Date.now());
+		io.log(style.info(`${displayName} status`));
+		printField("state", statusLabel(isAlive, isHealthy));
+		printField("pid", String(state.pid));
+		const extraFields = config.statusFields?.(state) ?? [];
+		for (const [label, value] of extraFields) printField(label, value);
+		printField("started", `${state.startedAt}${uptime ? ` (${uptime})` : ""}`);
+		printField("log", paths.logPath());
+		let exitCode = DAEMON_STATUS_EXIT_CODES.healthy;
+		if (!isAlive) exitCode = DAEMON_STATUS_EXIT_CODES.notRunning;
+		else if (!isHealthy) exitCode = DAEMON_STATUS_EXIT_CODES.unresponsive;
+		return {
+			exitCode,
+			isAlive,
+			isHealthy,
+			state
+		};
+	}
+	async function logs(options = {}) {
+		const logPath = paths.logPath();
+		if (!existsSync(logPath)) {
+			io.log(style.warn(`no ${displayName} log file yet`));
+			return 0;
+		}
+		if (options.follow === true) {
+			const child = spawn("tail", [
+				"-n",
+				String(options.lines ?? DEFAULT_LOG_LINES),
+				"-f",
+				logPath
+			], { stdio: "inherit" });
+			return await new Promise((resolve) => {
+				child.on("exit", (code) => {
+					resolve(code ?? 0);
+				});
+			});
+		}
+		const tail = readFileSync(logPath, "utf8").split("\n").slice(-(options.lines ?? DEFAULT_LOG_LINES));
+		io.log(tail.join("\n"));
+		return 0;
+	}
+	async function reset() {
+		await down();
+		const dir = paths.dir();
+		if (!existsSync(dir)) {
+			io.log(style.success("nothing to reset"));
+			return;
+		}
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+		io.log(style.success(`reset ${dir}`));
+	}
+	return {
+		clearState,
+		down,
+		logs,
+		paths,
+		readState,
+		reset,
+		resolveServerBin,
+		status,
+		up,
+		writeState
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@ariestools+cli-kit-node@1.2.3_@ariestools+actor-model@1.3.0_@ariestools+sdk@8.3.0_@ope_7b18c786a1c8bb7b1298534a22a75fd9/node_modules/@ariestools/cli-kit-node/dist/node/index.mjs
+function resolveEnvironmentValue(key, layers) {
+	for (const layer of layers) {
+		if (!Object.hasOwn(layer, key)) continue;
+		const value = layer[key];
+		if (value !== void 0) return value;
+	}
+}
+function mergeEnvironments(primary, ...fallbacks) {
+	const layers = [primary, ...fallbacks];
+	const keys = /* @__PURE__ */ new Set();
+	for (const layer of layers) for (const key of Object.keys(layer)) keys.add(key);
+	const result = {};
+	for (const key of keys) result[key] = resolveEnvironmentValue(key, layers);
+	return result;
+}
+var nodeProcessIO = {
+	get columns() {
+		return PROCESS.stdout.columns;
+	},
+	get isInteractive() {
+		return PROCESS.stdin.isTTY && PROCESS.stdout.isTTY;
+	},
+	error(...values) {
+		console.error(...values);
+	},
+	log(...values) {
+		console.log(...values);
+	},
+	async question(prompt) {
+		const readline = createInterface({
+			input: PROCESS.stdin,
+			output: PROCESS.stdout
+		});
+		try {
+			return await readline.question(prompt);
+		} finally {
+			readline.close();
+		}
+	},
+	warn(...values) {
+		console.warn(...values);
+	}
+};
+var DEFAULT_INTERRUPT_SIGNALS = ["SIGINT", "SIGTERM"];
+function createNodeProcessHost(options) {
+	const signals = options?.signals ?? DEFAULT_INTERRUPT_SIGNALS;
+	const environmentOverride = options?.environment;
+	const environmentDefaults = options?.environmentDefaults;
+	function resolveEnvironment() {
+		const primary = environmentOverride ?? PROCESS.env;
+		if (environmentDefaults === void 0) return primary;
+		return mergeEnvironments(primary, environmentDefaults);
+	}
+	return {
+		get argv() {
+			return PROCESS.argv;
+		},
+		get environment() {
+			return resolveEnvironment();
+		},
+		exit(code) {
+			PROCESS.exit(code);
+		},
+		get io() {
+			return nodeProcessIO;
+		},
+		get isDevelopment() {
+			return resolveEnvironment().NODE_ENV === "development";
+		},
+		onInterrupt(listener) {
+			const handleInterrupt = () => {
+				listener();
+			};
+			for (const signal of signals) PROCESS.on(signal, handleInterrupt);
+			return () => {
+				for (const signal of signals) PROCESS.off(signal, handleInterrupt);
+			};
+		}
+	};
+}
+var nodeProcessHost = createNodeProcessHost();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, postfix) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + postfix;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const isGotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, isGotCR ? index - 1 : index) + prefix + (isGotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/vendor/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+const ANSI_UNDERLINE_OFFSET = 20;
+const wrapAnsi16 = (offset = 0) => (code) => `\u{1B}[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u{1B}[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u{1B}[${38 + offset};2;${red};${green};${blue}m`;
+const wrapUnderlineAnsi = (code) => `\u{1B}[58;5;${code < 90 ? code - 30 : code - 90 + 8}m`;
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		underlineDouble: ["4:2", 24],
+		underlineCurly: ["4:3", 24],
+		underlineDotted: ["4:4", 24],
+		underlineDashed: ["4:5", 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	},
+	underlineColor: {
+		underlineBlack: ["58;5;0", 59],
+		underlineRed: ["58;5;1", 59],
+		underlineGreen: ["58;5;2", 59],
+		underlineYellow: ["58;5;3", 59],
+		underlineBlue: ["58;5;4", 59],
+		underlineMagenta: ["58;5;5", 59],
+		underlineCyan: ["58;5;6", 59],
+		underlineWhite: ["58;5;7", 59],
+		underlineBlackBright: ["58;5;8", 59],
+		underlineGray: ["58;5;8", 59],
+		underlineGrey: ["58;5;8", 59],
+		underlineRedBright: ["58;5;9", 59],
+		underlineGreenBright: ["58;5;10", 59],
+		underlineYellowBright: ["58;5;11", 59],
+		underlineBlueBright: ["58;5;12", 59],
+		underlineMagentaBright: ["58;5;13", 59],
+		underlineCyanBright: ["58;5;14", 59],
+		underlineWhiteBright: ["58;5;15", 59]
+	}
+};
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+Object.keys(styles$1.underlineColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u{1B}[${style[0]}m`,
+				close: `\u{1B}[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(Number.parseInt(style[0], 10), style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.underlineColor.close = "\x1B[59m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	styles$1.underlineColor.ansi = wrapUnderlineAnsi;
+	styles$1.underlineColor.ansi256 = wrapAnsi256(ANSI_UNDERLINE_OFFSET);
+	styles$1.underlineColor.ansi16m = wrapAnsi16m(ANSI_UNDERLINE_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[\da-f]{6}|[\da-f]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+const ansiStyles = assembleStyles();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : PROCESS.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = PROCESS;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function hasNumericForceColor() {
+	return /^\d+$/.test(env.FORCE_COLOR);
+}
+function envForceColor() {
+	if (!("FORCE_COLOR" in env)) return;
+	if (env.FORCE_COLOR === "false") return 0;
+	if (env.FORCE_COLOR === "true" || env.FORCE_COLOR.length === 0) return 1;
+	if (!hasNumericForceColor()) return;
+	return Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if (forceColor !== void 0 && hasNumericForceColor()) return forceColor;
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (PROCESS.platform === "win32") {
+		const osRelease = os.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".", 1)[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(?:color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/index.js
+const { stdout: stdoutColor, stderr: stderrColor } = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+const GENERATOR = Symbol("GENERATOR");
+const STYLER = Symbol("STYLER");
+const IS_EMPTY = Symbol("IS_EMPTY");
+const LEVEL = Symbol("LEVEL");
+const styles = Object.create(null);
+const assertValidLevel = (level) => {
+	if (!Number.isSafeInteger(level) || level < 0 || level > 3) throw new Error("The `level` should be an integer from 0 to 3");
+};
+const levelDescriptor = {
+	enumerable: true,
+	get() {
+		return this[LEVEL];
+	},
+	set(level) {
+		assertValidLevel(level);
+		this[LEVEL] = level;
+	}
+};
+const applyOptions = (object, options = {}) => {
+	if (options.level !== void 0) assertValidLevel(options.level);
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object[LEVEL] = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+const createModelConverters = (model, type) => {
+	const style = ansiStyles[type];
+	if (model === "rgb") {
+		const ansi = (red, green, blue) => style.ansi(ansiStyles.rgbToAnsi(red, green, blue));
+		const ansi256 = (red, green, blue) => style.ansi256(ansiStyles.rgbToAnsi256(red, green, blue));
+		return [
+			ansi,
+			ansi,
+			ansi256,
+			style.ansi16m
+		];
+	}
+	if (model === "hex") {
+		const ansi = (hex) => style.ansi(ansiStyles.hexToAnsi(hex));
+		const ansi256 = (hex) => style.ansi256(ansiStyles.hexToAnsi256(hex));
+		return [
+			ansi,
+			ansi,
+			ansi256,
+			(hex) => style.ansi16m(...ansiStyles.hexToRgb(hex))
+		];
+	}
+	const ansi = (code) => style.ansi(ansiStyles.ansi256ToAnsi(code));
+	return [
+		ansi,
+		ansi,
+		style.ansi256,
+		style.ansi256
+	];
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	const capitalizedModel = model[0].toUpperCase() + model.slice(1);
+	for (const [styleName, type] of [
+		[model, "color"],
+		["bg" + capitalizedModel, "bgColor"],
+		["underline" + capitalizedModel, "underlineColor"]
+	]) {
+		const { close } = ansiStyles[type];
+		const converters = createModelConverters(model, type);
+		styles[styleName] = { get() {
+			const styleFunction = function(first, second, third) {
+				const open = converters[this.level](first, second, third);
+				return createBuilder(this, createStyler(open, close, this[STYLER]), this[IS_EMPTY]);
+			};
+			Object.defineProperty(this, styleName, { value: styleFunction });
+			return styleFunction;
+		} };
+	}
+}
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => {
+		if (arguments_.length === 1) return applyStyle(builder, "" + arguments_[0]);
+		if (arguments_.length === 2) return applyStyle(builder, arguments_[0] + " " + arguments_[1]);
+		return applyStyle(builder, arguments_.join(" "));
+	};
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self[GENERATOR] ?? self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+const applyStyle = (self, string) => {
+	if (self[GENERATOR][LEVEL] <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, {
+	...styles,
+	level: levelDescriptor
+});
+const chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+//#endregion
+//#region ../datalake-core/dist/node/index.mjs
+var DATALAKE_CONTROL_AUDIENCE = "aries-datalake-control";
+var DATALAKE_CONTROL_OPERATIONS = [
+	"datalake:create",
+	"datalake:describe",
+	"datalake:list"
+];
+var DATALAKE_DATA_OPERATIONS = [
+	"payload:append",
+	"payload:read",
+	"usage:read"
+];
+DATALAKE_CONTROL_OPERATIONS.join(" ");
+DATALAKE_DATA_OPERATIONS.join(" ");
+//#endregion
+//#region ../cli-lib/dist/node/datalake.mjs
+var MONOREPO_BIN_SEARCH_PATHS = ["../../../cli/dist/bin", "../../../cli-internal/dist/bin"];
+function createDaemonKit(config) {
+	return createDaemonKit$1({
+		...config,
+		bin: {
+			...config.bin,
+			resolveFromUrl: import.meta.url,
+			searchPaths: MONOREPO_BIN_SEARCH_PATHS
+		},
+		homeDir: () => process.env.ARIES_HOME ?? path.join(homedir(), ".aries"),
+		host: nodeProcessHost,
+		style: {
+			dim: chalk.gray,
+			error: chalk.red,
+			info: chalk.cyan,
+			success: chalk.green,
+			warn: chalk.yellow
+		}
+	});
+}
+function normalizeDevState(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const state = value;
+	if (typeof state.pid !== "number" || !Number.isSafeInteger(state.pid) || state.pid <= 0) return void 0;
+	if (typeof state.startedAt !== "string") return void 0;
+	if (typeof state.controlUrl !== "string" || typeof state.planeUrl !== "string") return void 0;
+	const controlAudience = typeof state.controlAudience === "string" && state.controlAudience.length > 0 ? state.controlAudience : DATALAKE_CONTROL_AUDIENCE;
+	const corsOrigins = Array.isArray(state.corsOrigins) && state.corsOrigins.every((origin) => typeof origin === "string") ? [...new Set(state.corsOrigins)] : [];
+	const persistDir = typeof state.persistDir === "string" && state.persistDir.length > 0 ? state.persistDir : void 0;
+	return {
+		pid: state.pid,
+		startedAt: state.startedAt,
+		controlUrl: state.controlUrl,
+		planeUrl: state.planeUrl,
+		controlAudience,
+		corsOrigins,
+		...persistDir && { persistDir }
+	};
+}
+var devDaemon = createDaemonKit({
+	dirName: "dev",
+	displayName: "dev server",
+	bin: {
+		embeddedRelPath: "daemons/datalake-dev.mjs",
+		packageName: "@ariestools/aries-datalake-plane",
+		binRelPath: "dist/bin/devServer.mjs",
+		installHint: "Rebuild the CLI package so dist/bin/daemons/datalake-dev.mjs is embedded."
+	},
+	normalizeState: normalizeDevState,
+	health: { path: "/v1/health" },
+	baseUrl: (state) => state.controlUrl,
+	statusFields: (state) => [
+		["control", state.controlUrl],
+		["data", state.planeUrl],
+		["audience", state.controlAudience],
+		["cors", state.corsOrigins.join(", ") || "disabled"],
+		["store", state.persistDir ?? "in-memory"]
+	],
+	postDown: (state) => {
+		if (loadCredentials()?.baseUrl === state.controlUrl) clearCredentials();
+	}
+});
+var DEFAULT_TIMEOUT_MS = 1e3;
+async function inspectDatalakeDevServer(options = {}) {
+	const state = devDaemon.readState();
+	if (state === void 0) return {
+		schemaVersion: 1,
+		status: "stopped",
+		exitCode: 3,
+		process: {
+			running: false,
+			pid: null,
+			startedAt: null
+		},
+		endpoints: {
+			control: null,
+			plane: null
+		}
+	};
+	if (!isProcessAlive(state.pid)) return {
+		schemaVersion: 1,
+		status: "stale",
+		exitCode: 3,
+		process: {
+			running: false,
+			pid: state.pid,
+			startedAt: state.startedAt
+		},
+		endpoints: {
+			control: {
+				healthy: false,
+				url: state.controlUrl
+			},
+			plane: {
+				healthy: false,
+				url: state.planeUrl
+			}
+		}
+	};
+	const timeoutMs = normalizeTimeout(options.timeoutMs);
+	const [controlHealthy, planeHealthy] = await Promise.all([probeHealth(state.controlUrl, timeoutMs), probeHealth(state.planeUrl, timeoutMs)]);
+	const status = resolveStatus(controlHealthy, planeHealthy);
+	return {
+		schemaVersion: 1,
+		status,
+		exitCode: status === "healthy" ? 0 : 2,
+		process: {
+			running: true,
+			pid: state.pid,
+			startedAt: state.startedAt
+		},
+		endpoints: {
+			control: {
+				healthy: controlHealthy,
+				url: state.controlUrl
+			},
+			plane: {
+				healthy: planeHealthy,
+				url: state.planeUrl
+			}
+		}
+	};
+}
+function normalizeTimeout(value) {
+	if (value === void 0) return DEFAULT_TIMEOUT_MS;
+	if (!Number.isFinite(value) || value <= 0) throw new Error("timeoutMs must be a positive number");
+	return value;
+}
+async function probeHealth(baseUrl, timeoutMs) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return (await fetch(`${baseUrl.replace(/\/$/, "")}/v1/health`, { signal: controller.signal })).ok;
+	} catch {
+		return false;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+function resolveStatus(controlHealthy, planeHealthy) {
+	if (controlHealthy && planeHealthy) return "healthy";
+	if (controlHealthy || planeHealthy) return "degraded";
+	return "unresponsive";
+}
+//#endregion
+export { LocalDatalakeClient, RestDatalakeClient, RestPayloadsClient, clearCredentials, clearDefaultDatalake, createDatalakeClient, getCredentialsLocation, getDefaultDatalake, inspectDatalakeDevServer, loadCredentials, saveCredentials, setDefaultDatalake };