@ariestools/cli 0.1.18 → 0.1.20

package/dist/node/datalake.mjs

@@ -68,6 +68,473 @@ var DATALAKE_DATA_OPERATIONS = [
 DATALAKE_CONTROL_OPERATIONS.join(" ");
 DATALAKE_DATA_OPERATIONS.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
+var fetchErrorMarker = "$$xylabs-fetch-error";
+var codeTypes = {
+	ENOTFOUND: "dns",
+	EAI_AGAIN: "dns",
+	ECONNREFUSED: "connection-refused",
+	ECONNRESET: "connection-reset",
+	EPIPE: "connection-reset",
+	ETIMEDOUT: "connection-timeout",
+	UND_ERR_CONNECT_TIMEOUT: "connection-timeout",
+	UND_ERR_HEADERS_TIMEOUT: "timeout",
+	UND_ERR_BODY_TIMEOUT: "timeout",
+	EHOSTUNREACH: "unreachable",
+	ENETUNREACH: "unreachable",
+	CERT_HAS_EXPIRED: "tls",
+	DEPTH_ZERO_SELF_SIGNED_CERT: "tls",
+	UNABLE_TO_VERIFY_LEAF_SIGNATURE: "tls",
+	SELF_SIGNED_CERT_IN_CHAIN: "tls",
+	ERR_TLS_CERT_ALTNAME_INVALID: "tls"
+};
+function findErrorCode(error) {
+	let current = error;
+	for (let depth = 0; depth < 8 && current instanceof Error; depth++) {
+		const code = current.code;
+		if (typeof code === "string") return code;
+		current = current.cause;
+	}
+}
+function typeFromCode(code) {
+	if (Object.hasOwn(codeTypes, code)) return codeTypes[code];
+	if (code.startsWith("CERT_") || code.startsWith("ERR_TLS_")) return "tls";
+}
+function classifyFetchError(error) {
+	if (error instanceof Error) {
+		if (error.name === "TimeoutError") return { type: "timeout" };
+		if (error.name === "AbortError") return { type: "aborted" };
+	}
+	const code = findErrorCode(error);
+	if (code !== void 0) {
+		const type = typeFromCode(code);
+		if (type !== void 0) return {
+			type,
+			code
+		};
+		return {
+			type: "unknown",
+			code
+		};
+	}
+	if (error instanceof TypeError && /fetch failed|failed to fetch|network/i.test(error.message)) return { type: "network" };
+	return { type: "unknown" };
+}
+var FetchError = class extends Error {
+	/** Cross-realm marker consumed by {@link isFetchError}. */
+	__fetchErrorMarker = fetchErrorMarker;
+	/** Raw unparseable body text for `parse` failures. */
+	body;
+	/** Node, undici, or TLS system error code when available. */
+	code;
+	/** HTTP method associated with the failed request. */
+	method;
+	/** Parsed response for rejected HTTP-status requests. */
+	response;
+	/** HTTP status when a response was received. */
+	status;
+	/** HTTP reason phrase when a response was received. */
+	statusText;
+	/** Classified reason for the fetch failure. */
+	type;
+	/** Request URL associated with the failure. */
+	url;
+	/** Creates a structured fetch error from a message and request context. */
+	constructor(message, context = {}) {
+		super(message, { cause: context.cause });
+		this.name = "FetchError";
+		this.type = context.type ?? "unknown";
+		this.code = context.code;
+		this.url = context.url;
+		this.method = context.method;
+		this.status = context.status;
+		this.statusText = context.statusText;
+		this.response = context.response;
+		this.body = context.body;
+	}
+	/** Returns a circular-reference-free representation for logs and telemetry. */
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			type: this.type,
+			code: this.code,
+			url: this.url,
+			method: this.method,
+			status: this.status,
+			statusText: this.statusText
+		};
+	}
+};
+function isFetchError(value) {
+	return value instanceof FetchError || typeof value === "object" && value !== null && value.__fetchErrorMarker === fetchErrorMarker;
+}
+function toFetchError(error, context = {}) {
+	if (isFetchError(error)) return error;
+	const { type, code } = classifyFetchError(error);
+	return new FetchError(error instanceof Error ? error.message : String(error), {
+		...context,
+		type,
+		code,
+		cause: error
+	});
+}
+function fetchDefault(input, init) {
+	return globalThis.fetch(input, init);
+}
+async function gzipString(body) {
+	const stream = new Blob([body]).stream().pipeThrough(new CompressionStream("gzip"));
+	return new Response(stream).arrayBuffer();
+}
+async function fetchCompress(url, options = {}) {
+	const { compressMinLength = 1024, fetcher = fetchDefault, ...init } = options;
+	try {
+		if (init.body !== void 0 && init.body !== null) {
+			const bodyStr = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
+			if (bodyStr.length > compressMinLength) {
+				const headers = new Headers(init.headers);
+				headers.set("Content-Encoding", "gzip");
+				return await fetcher(url, {
+					...init,
+					body: await gzipString(bodyStr),
+					headers
+				});
+			}
+		}
+		return await fetcher(url, init);
+	} catch (error) {
+		throw toFetchError(error, {
+			url: url.toString(),
+			method: init.method
+		});
+	}
+}
+function validateMaxResponseBytes(maxResponseBytes) {
+	if (maxResponseBytes !== void 0 && (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)) throw new RangeError("maxResponseBytes must be a positive safe integer");
+}
+function abortError(signal) {
+	const reason = signal.reason;
+	let isTimeout = false;
+	try {
+		isTimeout = typeof reason === "object" && reason !== null && "name" in reason && reason.name === "TimeoutError" || classifyFetchError(reason).type === "timeout";
+	} catch {}
+	return new FetchError("Response body read was aborted", {
+		type: isTimeout ? "timeout" : "aborted",
+		cause: reason
+	});
+}
+function readChunk(reader, signal) {
+	if (signal == null) return reader.read();
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const finish = (outcome) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			if ("error" in outcome) reject(toFetchError(outcome.error));
+			else resolve(outcome.value);
+		};
+		const onAbort = () => finish({ error: abortError(signal) });
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		try {
+			reader.read().then((value) => signal.aborted ? onAbort() : finish({ value })).catch((error) => finish({ error }));
+		} catch (error) {
+			finish({ error });
+		}
+	});
+}
+function cancelReader(reader, reason) {
+	try {
+		reader.cancel(reason).catch(() => {});
+	} catch {}
+}
+async function readStreamText(reader, maxResponseBytes, signal, response) {
+	const decoder = new TextDecoder();
+	const parts = [];
+	let bytes = 0;
+	let completed = false;
+	let failure;
+	try {
+		while (true) {
+			const result = await readChunk(reader, signal);
+			if (signal?.aborted === true) throw abortError(signal);
+			if (result.done) {
+				parts.push(decoder.decode());
+				completed = true;
+				return parts.join("");
+			}
+			const chunk = result.value;
+			if (!ArrayBuffer.isView(chunk) || Object.prototype.toString.call(chunk) !== "[object Uint8Array]") throw new TypeError("Response body chunks must be Uint8Array values");
+			if (maxResponseBytes !== void 0) {
+				if (chunk.byteLength > maxResponseBytes - bytes) throw new FetchError("Response body exceeds maxResponseBytes", {
+					type: "response-too-large",
+					status: response.status,
+					statusText: response.statusText
+				});
+				bytes += chunk.byteLength;
+			}
+			const text = decoder.decode(chunk, { stream: true });
+			if (text !== "") parts.push(text);
+		}
+	} catch (error) {
+		failure = error;
+		throw error;
+	} finally {
+		if (!completed) cancelReader(reader, failure);
+		reader.releaseLock();
+	}
+}
+async function readResponseText(response, options = {}) {
+	const { maxResponseBytes, signal } = options;
+	validateMaxResponseBytes(maxResponseBytes);
+	if (maxResponseBytes === void 0 && signal == null) return await response.text();
+	if (response.bodyUsed) throw new TypeError("Response body has already been consumed");
+	const body = response.body;
+	if (body === null) {
+		if (signal?.aborted === true) throw abortError(signal);
+		return "";
+	}
+	return await readStreamText(body.getReader(), maxResponseBytes, signal, response);
+}
+function contextualizeReadError(error, context, options) {
+	const failure = toFetchError(error, context);
+	if (options.maxResponseBytes === void 0 && options.signal == null) return failure;
+	if ((failure.url !== void 0 || context.url === void 0) && (failure.method !== void 0 || context.method === void 0)) return failure;
+	return new FetchError(failure.message, {
+		body: failure.body,
+		cause: failure.cause,
+		code: failure.code,
+		method: failure.method ?? context.method,
+		response: failure.response,
+		status: failure.status,
+		statusText: failure.statusText,
+		type: failure.type,
+		url: failure.url ?? context.url
+	});
+}
+async function parseJsonResponse(response, context = {}, options = {}) {
+	let text;
+	try {
+		text = await readResponseText(response, options);
+	} catch (error) {
+		throw contextualizeReadError(error, context, options);
+	}
+	if (text.trim() === "") return null;
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new FetchError("Failed to parse response body as JSON", {
+			type: "parse",
+			url: context.url,
+			method: context.method,
+			status: response.status,
+			statusText: response.statusText,
+			body: text,
+			cause: error
+		});
+	}
+}
+async function tryParseJson(response, options = {}, context = {}) {
+	let text;
+	try {
+		text = await readResponseText(response, options);
+	} catch (error) {
+		if (options.maxResponseBytes !== void 0 || options.signal != null) throw contextualizeReadError(error, context, options);
+		return null;
+	}
+	try {
+		return text.trim() === "" ? null : JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+function noop() {}
+function requestSignal(signal, timeout) {
+	if (timeout === void 0 || timeout === 0) return {
+		signal,
+		close: noop
+	};
+	const timeoutSignal = AbortSignal.timeout(timeout);
+	if (signal == null) return {
+		signal: timeoutSignal,
+		close: noop
+	};
+	const controller = new AbortController();
+	const close = () => {
+		signal.removeEventListener("abort", onCallerAbort);
+		timeoutSignal.removeEventListener("abort", onTimeout);
+	};
+	const abort = (source) => {
+		if (!controller.signal.aborted) controller.abort(source.reason);
+		close();
+	};
+	const onCallerAbort = () => abort(signal);
+	const onTimeout = () => abort(timeoutSignal);
+	signal.addEventListener("abort", onCallerAbort, { once: true });
+	timeoutSignal.addEventListener("abort", onTimeout, { once: true });
+	if (signal.aborted) onCallerAbort();
+	else if (timeoutSignal.aborted) onTimeout();
+	return {
+		signal: controller.signal,
+		close
+	};
+}
+var FetchClientError = class extends FetchError {
+	/** Effective request configuration, including the resolved request URL. */
+	config;
+	/** Creates an HTTP-status error with its response and request configuration. */
+	constructor(message, response, config) {
+		super(message, {
+			type: "http-status",
+			url: config.url,
+			method: config.method,
+			status: response.status,
+			statusText: response.statusText,
+			response
+		});
+		this.name = "FetchClientError";
+		this.config = config;
+	}
+};
+function buildHeaders(custom, includeContentType = false) {
+	const headers = new Headers();
+	headers.set("Accept", "application/json, text/plain, *.*");
+	if (includeContentType) headers.set("Content-Type", "application/json");
+	if (custom) {
+		const merged = new Headers(custom);
+		for (const [key, value] of merged.entries()) headers.set(key, value);
+	}
+	return headers;
+}
+function buildURL(config) {
+	const base = config.baseURL ?? "";
+	const path = config.url ?? "";
+	const url = base === "" ? new URL(path) : new URL(path, base);
+	if (config.params) for (const [key, value] of Object.entries(config.params)) url.searchParams.set(key, value);
+	return url.href;
+}
+var FetchClient = class _FetchClient {
+	/** Instance defaults shallow-merged beneath every request configuration. */
+	defaults;
+	/** Creates a client with reusable request defaults. */
+	constructor(defaults = {}) {
+		this.defaults = defaults;
+	}
+	/** Creates a client with the supplied request defaults. */
+	static create(config) {
+		return new _FetchClient(config);
+	}
+	/** Sends a `DELETE` request and parses its response as JSON. */
+	delete(url, config) {
+		return this.request({
+			...config,
+			url,
+			method: "DELETE"
+		});
+	}
+	/** Sends a `GET` request and parses its response as JSON. */
+	get(url, config) {
+		return this.request({
+			...config,
+			url,
+			method: "GET"
+		});
+	}
+	/** Serializes `data`, sends a `PATCH` request, and parses the JSON response. */
+	patch(url, data, config) {
+		return this.request({
+			...config,
+			url,
+			data,
+			method: "PATCH"
+		});
+	}
+	/** Serializes `data`, sends a `POST` request, and parses the JSON response. */
+	post(url, data, config) {
+		return this.request({
+			...config,
+			url,
+			data,
+			method: "POST"
+		});
+	}
+	/** Serializes `data`, sends a `PUT` request, and parses the JSON response. */
+	put(url, data, config) {
+		return this.request({
+			...config,
+			url,
+			data,
+			method: "PUT"
+		});
+	}
+	/**
+	* Resolves and executes a request using native fetch semantics.
+	* @returns Response metadata and parsed JSON, or `null` for an empty body.
+	* @throws {@link FetchClientError} when `validateStatus` rejects the status.
+	* @throws {@link FetchError} for transport or JSON parsing failures.
+	*/
+	async request(config) {
+		const merged = {
+			...this.defaults,
+			...config
+		};
+		const url = buildURL(merged);
+		const { baseURL: _baseURL, data: requestData, headers, maxResponseBytes, method = "GET", params: _params, signal, timeout, url: _url, validateStatus: validateStatusOption, ...requestInit } = merged;
+		validateMaxResponseBytes(maxResponseBytes);
+		const scope = requestSignal(signal, timeout);
+		try {
+			const init = {
+				...requestInit,
+				method,
+				headers: buildHeaders(headers, requestData !== void 0),
+				signal: scope.signal
+			};
+			if (requestData !== void 0) init.body = JSON.stringify(requestData);
+			const response = await fetchCompress(url, init);
+			const readOptions = {
+				maxResponseBytes,
+				signal: scope.signal
+			};
+			const result = {
+				data: response.ok ? await parseJsonResponse(response, {
+					url,
+					method
+				}, readOptions) : await tryParseJson(response, readOptions, {
+					url,
+					method
+				}),
+				headers: response.headers,
+				response,
+				status: response.status,
+				statusText: response.statusText
+			};
+			const validateStatus = validateStatusOption === void 0 ? (s) => s >= 200 && s < 300 : validateStatusOption;
+			if (validateStatus && !validateStatus(response.status)) throw new FetchClientError(`Request failed with status ${response.status} ${response.statusText}`, result, {
+				...merged,
+				method,
+				url
+			});
+			return result;
+		} finally {
+			scope.close();
+		}
+	}
+};
+new class _FetchJsonClient extends FetchClient {
+	/** Creates a JSON client with reusable request and compression defaults. */
+	constructor(config) {
+		super(config);
+	}
+	/** Creates a JSON client with the supplied defaults. */
+	static create(config) {
+		return new _FetchJsonClient(config);
+	}
+}();
+//#endregion
 //#region ../datalake-client/dist/node/index.mjs
 function getAriesHome() {
 	return process.env.ARIES_HOME ?? path.join(homedir(), ".aries");
@@ -378,6 +845,22 @@ function extractRequestBase(urlWithPossiblePath) {
 		return urlWithPossiblePath.replace(/\/$/, "");
 	}
 }
+function parsePayloadResponse(response, text, method) {
+	const payload = text.length > 0 ? JSON.parse(text) : void 0;
+	if (!response.ok) {
+		const errorBody = isApiErrorBody2(payload) ? payload : {
+			code: "internal",
+			message: "Unexpected " + response.status + " response from " + method + " data plane"
+		};
+		throw new DatalakeApiError(response.status, errorBody);
+	}
+	return payload;
+}
+function isApiErrorBody2(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.code === "string" && typeof maybe.message === "string";
+}
 var RestPayloadsClient = class {
 	authToken;
 	datalakeId;
@@ -458,17 +941,8 @@ var RestPayloadsClient = class {
 			data: void 0,
 			headers: response.headers
 		};
-		const text = await response.text();
-		const payload = text.length > 0 ? JSON.parse(text) : void 0;
-		if (!response.ok) {
-			const errorBody = isApiErrorBody2(payload) ? payload : {
-				code: "internal",
-				message: `Unexpected ${response.status} response from ${method} data plane`
-			};
-			throw new DatalakeApiError(response.status, errorBody);
-		}
 		return {
-			data: payload,
+			data: parsePayloadResponse(response, await response.text(), method),
 			headers: response.headers
 		};
 	}
@@ -483,10 +957,5 @@ function readInsertSummary(headers) {
 		rejected
 	};
 }
-function isApiErrorBody2(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const maybe = value;
-	return typeof maybe.code === "string" && typeof maybe.message === "string";
-}
 //#endregion
 export { LocalDatalakeClient, RestDatalakeClient, RestPayloadsClient, clearCredentials, clearDefaultDatalake, createDatalakeClient, getCredentialsLocation, getDefaultDatalake, loadCredentials, saveCredentials, setDefaultDatalake };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ariestools/cli",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Aries Tools CLI - A suite of tools by Arie Trouw",
   "keywords": [
     "ariestools",
@@ -35,38 +35,38 @@
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.1",
-    "@xyo-network/archivist-lmdb": "~7.2.3",
-    "@xyo-network/sdk-protocol": "~7.2.4",
-    "@xyo-network/xl1-cli": "~5.0.4",
+    "@xyo-network/archivist-lmdb": "~7.4.0",
+    "@xyo-network/sdk-protocol": "~7.4.2",
+    "@xyo-network/xl1-cli": "~5.3.0",
     "async-mutex": "~0.5.0",
     "ethers": "~6.17.0",
     "pdq-wasm": "~0.3.9",
     "s3rver": "~3.7.1",
-    "zod": "~4.4.3",
-    "@ariestools/aries-dapp-core": "~0.1.18",
-    "@ariestools/aries-dapp-serve": "~0.1.18",
-    "@xyo-network/wallet-xl1-cli": "~0.1.18"
+    "zod": "~4.5.1",
+    "@ariestools/aries-dapp-core": "~0.1.20",
+    "@ariestools/aries-dapp-serve": "~0.1.20",
+    "@xyo-network/wallet-xl1-cli": "~0.1.20"
   },
   "devDependencies": {
     "@ariestools/actor": "~1.3.0",
     "@ariestools/actor-model": "~1.3.0",
     "@ariestools/cli-kit-daemon": "~1.2.3",
-    "@ariestools/sdk": "~8.1.9",
-    "@ariestools/toolchain": "~9.0.2",
-    "@ariestools/tsconfig": "~9.0.2",
-    "@types/node": "~26.2.0",
-    "@xyo-network/sdk": "~7.2.3",
-    "@xyo-network/xl1-sdk": "~5.2.3",
-    "eslint": "~10.8.1",
-    "rolldown": "~1.2.4",
+    "@ariestools/sdk": "~8.2.0",
+    "@ariestools/toolchain": "~9.1.2",
+    "@ariestools/tsconfig": "~9.1.2",
+    "@types/node": "~26.4.0",
+    "@xyo-network/sdk": "~7.4.0",
+    "@xyo-network/xl1-sdk": "~5.4.1",
+    "eslint": "~10.9.1",
+    "rolldown": "~1.2.6",
     "tsx": "~4.23.12",
     "typescript": "~6.0.3",
-    "vite": "~8.2.1",
-    "vitest": "~4.1.10",
+    "vite": "~8.2.2",
+    "vitest": "~4.1.11",
     "yargs": "~18.1.0",
-    "@ariestools/aries-cli-core": "~0.1.18",
-    "@ariestools/aries-datalake-client": "~0.1.18",
-    "@ariestools/cli-lib": "~0.1.18"
+    "@ariestools/aries-cli-core": "~0.1.20",
+    "@ariestools/aries-datalake-client": "~0.1.20",
+    "@ariestools/cli-lib": "~0.1.20"
   },
   "engines": {
     "node": ">=24"