@dungsil/dsh-plugin-cli-proxy-api 0.0.0-stage → 0.0.0

package/dist/index.js

@@ -0,0 +1,1737 @@
+import { createHash, randomUUID } from "node:crypto";
+import { clientRequestSchema } from "@deepseek-ai/dsh-client-connection";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+// ../../node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.6/node_modules/@deepseek-ai/cosmokit/lib/index.js
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+/** Shared config references used by schema validators and plugin runtimes. */
+const write = Symbol.for("cosmokit.volatile.write");
+function snapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (typeof value === "function") throw new TypeError("volatile config cannot contain functions");
+	if (value === null || typeof value !== "object") return value;
+	if (ancestors.has(value)) throw new TypeError("volatile config cannot contain cycles");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) return Object.freeze(value.map((item) => snapshot(item, ancestors)));
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new TypeError("volatile config objects must be plain objects or arrays");
+		return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, snapshot(item, ancestors)])));
+	} finally {
+		ancestors.delete(value);
+	}
+}
+/**
+* Create a detached reference containing an immutable copy of the supplied data.
+* @param value - validated config data; class instances and functions are unsupported.
+* @returns a reference whose value is updated only by its owning runtime.
+*/
+function createVolatile(value) {
+	let current = snapshot(value);
+	return Object.freeze({
+		get: () => current,
+		[write]: (value) => {
+			current = value;
+		}
+	});
+}
+/**
+* Identify references across ESM/CJS copies of the shared library.
+* @param value - a parsed config value.
+* @returns whether the value implements the shared reference protocol.
+*/
+function isVolatile(value) {
+	return typeof value === "object" && value !== null && write in value;
+}
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+/** Binary source detection and base64/hex conversion helpers. */
+var Binary;
+(function(Binary) {
+	Binary.is = isArrayBufferLike;
+	Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+Binary.fromBase64;
+Binary.toBase64;
+Binary.fromHex;
+Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/**
+* Compare values recursively, treating two volatile references as equal regardless of value.
+* Strict comparison distinguishes null/undefined, treats opaque objects by identity,
+* compares URLs by normalized href, treats array holes as undefined, and considers distinct cyclic structures unequal.
+* @param a - first value.
+* @param b - second value.
+* @param strict - whether to require strict data equality outside volatile references.
+* @returns whether the values compare equal.
+*/
+function deepEqual(a, b, strict) {
+	const ancestors = /* @__PURE__ */ new Set();
+	function compare(a, b) {
+		if (a === b) return true;
+		if (isVolatile(a) || isVolatile(b)) return isVolatile(a) && isVolatile(b);
+		if (!strict && isNullable(a) && isNullable(b)) return true;
+		if (typeof a !== typeof b || typeof a !== "object" || !a || !b) return false;
+		if (ancestors.has(a)) return false;
+		function check(test, then) {
+			return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+		}
+		ancestors.add(a);
+		try {
+			return check(Array.isArray, (a, b) => {
+				if (a.length !== b.length) return false;
+				for (let index = 0; index < a.length; index++) if (!compare(a[index], b[index])) return false;
+				return true;
+			}) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("URL"), (a, b) => a.href === b.href) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+				if (a.byteLength !== b.byteLength) return false;
+				const viewA = new Uint8Array(a);
+				const viewB = new Uint8Array(b);
+				for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+				return true;
+			}) ?? ((!strict || [a, b].every((value) => Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) && Object.keys({
+				...a,
+				...b
+			}).every((key) => compare(a[key], b[key])));
+		} finally {
+			ancestors.delete(a);
+		}
+	}
+	return compare(a, b);
+}
+/** Time constants plus parsing and formatting helpers. */
+var Time;
+(function(Time) {
+	Time.millisecond = 1;
+	Time.second = 1e3;
+	Time.minute = Time.second * 60;
+	Time.hour = Time.minute * 60;
+	Time.day = Time.hour * 24;
+	Time.week = Time.day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+	}
+	Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * Time.day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * Time.minute);
+	}
+	Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+	}
+	Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+		else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+		else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+		else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+		return ms + "ms";
+	}
+	Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	Time.template = template;
+})(Time || (Time = {}));
+// ../../node_modules/.pnpm/@deepseek-ai+schemastery@3.18.5/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+const kSchema = Symbol.for("schemastery");
+const kValidationError = Symbol.for("ValidationError");
+globalThis.__schemastery_index__ ??= 0;
+globalThis.__schemastery_refs__ = void 0;
+var ValidationError = class extends TypeError {
+	options;
+	name = "ValidationError";
+	constructor(message, options) {
+		let prefix = "$";
+		for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+		else if (typeof segment === "number") prefix += "[" + segment + "]";
+		else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+		if (prefix.startsWith(".")) prefix = prefix.slice(1);
+		super((prefix === "$" ? "" : `${prefix} `) + message);
+		this.options = options;
+	}
+	static is(error) {
+		return !!error?.[kValidationError];
+	}
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+const Schema = function(options) {
+	const schema = function(data, options = {}) {
+		return Schema.resolve(data, schema, options)[0];
+	};
+	if (options.refs) {
+		const refs = mapValues(options.refs, (options) => new Schema(options));
+		const getRef = (uid) => refs[uid];
+		for (const key in refs) {
+			const options = refs[key];
+			options.sKey = getRef(options.sKey);
+			options.inner = getRef(options.inner);
+			options.list = options.list && options.list.map(getRef);
+			options.dict = options.dict && mapValues(options.dict, getRef);
+		}
+		return refs[options.uid];
+	}
+	Object.assign(schema, options);
+	if (typeof schema.callback === "string") try {
+		schema.callback = new Function("return " + schema.callback)();
+	} catch {}
+	Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+	Object.setPrototypeOf(schema, Schema.prototype);
+	schema.meta ||= {};
+	schema.toString = schema.toString.bind(schema);
+	return schema;
+};
+Schema.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", { get() {
+	return {
+		version: 1,
+		vendor: "schemastery",
+		validate: (value) => {
+			try {
+				return { value: Schema.resolve(value, this, {})[0] };
+			} catch (error) {
+				if (ValidationError.is(error)) return { issues: [{
+					message: error.message,
+					path: error.options.path
+				}] };
+				throw error;
+			}
+		}
+	};
+} });
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = function toJSON() {
+	if (globalThis.__schemastery_refs__) {
+		globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+		return this.uid;
+	}
+	globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+	globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+	const result = {
+		uid: this.uid,
+		refs: globalThis.__schemastery_refs__
+	};
+	globalThis.__schemastery_refs__ = void 0;
+	return result;
+};
+Schema.prototype.set = function set(key, value) {
+	this.dict[key] = value;
+	return this;
+};
+Schema.prototype.push = function push(value) {
+	this.list.push(value);
+	return this;
+};
+function mergeDesc(original, messages) {
+	const result = typeof original === "string" ? { "": original } : { ...original };
+	for (const locale in messages) {
+		const value = messages[locale];
+		if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+		else if (typeof value === "string") result[locale] = value;
+	}
+	return result;
+}
+function getInner(value) {
+	return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+	return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = function i18n(messages) {
+	const schema = Schema(this);
+	const desc = mergeDesc(schema.meta.description, messages);
+	if (Object.keys(desc).length) schema.meta.description = desc;
+	if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+		return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+	});
+	if (schema.list) schema.list = schema.list.map((inner, index) => {
+		return inner.i18n(mapValues(messages, (data = {}) => {
+			if (Array.isArray(getInner(data))) return getInner(data)[index];
+			if (Array.isArray(data)) return data[index];
+			return extractKeys(data);
+		}));
+	});
+	if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+		if (getInner(data)) return getInner(data);
+		return extractKeys(data);
+	}));
+	if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+	return schema;
+};
+Schema.prototype.extra = function extra(key, value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+};
+for (const key of [
+	"required",
+	"disabled",
+	"collapse",
+	"hidden",
+	"loose"
+]) Object.assign(Schema.prototype, { [key](value = true) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.deprecated = function deprecated() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "deprecated",
+		type: "danger"
+	});
+	return schema;
+};
+Schema.prototype.experimental = function experimental() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "experimental",
+		type: "warning"
+	});
+	return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+	const schema = Schema(this);
+	const pattern = pick(regexp, ["source", "flags"]);
+	schema.meta = {
+		...schema.meta,
+		pattern
+	};
+	return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+	if (isVolatile(value)) value = value.get();
+	if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+	if (isNullable(value)) return value;
+	if (this.type === "object" || this.type === "dict") {
+		const result = {};
+		for (const key in value) {
+			const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+			if (this.type === "dict" || !isNullable(item)) result[key] = item;
+		}
+		if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+		return result;
+	} else if (this.type === "array" || this.type === "tuple") {
+		const result = [];
+		value.forEach((value, index) => {
+			const schema = this.type === "array" ? this.inner : this.list[index];
+			const item = schema ? schema.simplify(value) : value;
+			result.push(item);
+		});
+		return result;
+	} else if (this.type === "intersect") {
+		const result = {};
+		for (const item of this.list) Object.assign(result, item.simplify(value));
+		return result;
+	} else if (this.type === "union") for (const schema of this.list) try {
+		Schema.resolve(value, schema, {});
+		return schema.simplify(value);
+	} catch {}
+	return value;
+};
+Schema.prototype.toString = function toString(inline) {
+	return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role, extra) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		role,
+		extra
+	};
+	return schema;
+};
+for (const key of [
+	"default",
+	"link",
+	"comment",
+	"description",
+	"max",
+	"min",
+	"step"
+]) Object.assign(Schema.prototype, { [key](value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.volatile = function volatile() {
+	if (this.meta.volatile) throw new TypeError("volatile schema is already wrapped");
+	return this.extra("volatile", true);
+};
+const resolvers = {};
+const checkedVolatile = Symbol("checked-volatile-schema");
+function validateVolatileSchema(schema, path = [], blocked = false, seen = /* @__PURE__ */ new Map()) {
+	const states = seen.get(schema) ?? /* @__PURE__ */ new Set();
+	if (states.has(blocked)) return;
+	states.add(blocked);
+	seen.set(schema, states);
+	if (schema.meta?.volatile && blocked) throw new ValidationError("volatile fields require a fixed object path without an enclosing volatile field", { path });
+	const nested = blocked || !!schema.meta?.volatile;
+	if (schema.dict) for (const [key, child] of Object.entries(schema.dict)) validateVolatileSchema(child, [...path, key], nested, seen);
+	if (schema.sKey) validateVolatileSchema(schema.sKey, [...path, "<key>"], true, seen);
+	if (schema.inner && (schema.type !== "lazy" || schema.inner[kSchema])) validateVolatileSchema(schema.inner, [...path, "*"], true, seen);
+	if (schema.list) for (let index = 0; index < schema.list.length; index++) validateVolatileSchema(schema.list[index], [...path, String(index)], true, seen);
+}
+Schema.extend = function extend(type, resolve) {
+	resolvers[type] = resolve;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+	if (!schema) return [data];
+	if (!options[checkedVolatile]) {
+		validateVolatileSchema(schema, options.path);
+		options = {
+			...options,
+			[checkedVolatile]: true
+		};
+	}
+	if (schema.meta?.volatile) {
+		const inner = Schema(schema);
+		inner.meta = {
+			...schema.meta,
+			volatile: false
+		};
+		const [value, adapted] = Schema.resolve(data, inner, options, strict);
+		try {
+			return [createVolatile(value), adapted];
+		} catch (error) {
+			throw new ValidationError(error instanceof Error ? error.message : String(error), options);
+		}
+	}
+	if (options.ignore?.(data, schema)) return [data];
+	if (isNullable(data) && schema.type !== "lazy") {
+		if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+		let current = schema;
+		let fallback = schema.meta.default;
+		while (current?.type === "intersect" && isNullable(fallback)) {
+			current = current.list[0];
+			fallback = current?.meta.default;
+		}
+		if (isNullable(fallback)) return [data];
+		data = clone(fallback);
+	}
+	const callback = resolvers[schema.type];
+	if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+	try {
+		return callback(data, schema, options, strict);
+	} catch (error) {
+		if (!schema.meta.loose) throw error;
+		return [schema.meta.default];
+	}
+};
+Schema.from = function from(source) {
+	if (isNullable(source)) return Schema.any();
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source)) return Schema.const(source).required();
+	else if (source[kSchema]) return source;
+	else if (typeof source === "function") switch (source) {
+		case String: return Schema.string().required();
+		case Number: return Schema.number().required();
+		case Boolean: return Schema.boolean().required();
+		case Function: return Schema.function().required();
+		default: return Schema.is(source).required();
+	}
+	else throw new TypeError(`cannot infer schema from ${source}`);
+};
+Schema.lazy = function lazy(builder) {
+	const toJSON = () => {
+		if (!schema.inner[kSchema]) {
+			schema.inner = schema.builder();
+			schema.inner.meta = {
+				...schema.meta,
+				...schema.inner.meta
+			};
+		}
+		return schema.inner.toJSON();
+	};
+	const schema = new Schema({
+		type: "lazy",
+		builder,
+		inner: { toJSON }
+	});
+	return schema;
+};
+Schema.natural = function natural() {
+	return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+	return Schema.number().step(.01).min(0).max(1).role("slider");
+};
+Schema.date = function date() {
+	return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+		const date = new Date(value);
+		if (isNaN(+date)) throw new ValidationError(`invalid date "${value}"`, options);
+		return date;
+	}, true)]);
+};
+Schema.regExp = function regExp(flag = "") {
+	return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+		try {
+			return new RegExp(value, flag);
+		} catch (e) {
+			throw new ValidationError(e.message, options);
+		}
+	}, true)]);
+};
+Schema.arrayBuffer = function arrayBuffer(encoding) {
+	return Schema.union([
+		Schema.is(ArrayBuffer),
+		Schema.is(SharedArrayBuffer),
+		Schema.transform(Schema.any(), (value, options) => {
+			if (Binary.isSource(value)) return Binary.fromSource(value);
+			throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+		}, true),
+		...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+			try {
+				return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+			} catch (e) {
+				throw new ValidationError(e.message, options);
+			}
+		}, true)] : []
+	]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+	if (!schema.inner[kSchema]) {
+		schema.inner = schema.builder();
+		schema.inner.meta = {
+			...schema.meta,
+			...schema.inner.meta
+		};
+		validateVolatileSchema(schema.inner, options.path, true);
+	}
+	return Schema.resolve(data, schema.inner, options, strict);
+});
+Schema.extend("any", (data) => {
+	return [data];
+});
+Schema.extend("never", (data, _, options) => {
+	throw new ValidationError(`expected nullable but got ${data}`, options);
+});
+Schema.extend("const", (data, { value }, options) => {
+	if (deepEqual(data, value)) return [value];
+	throw new ValidationError(`expected ${value} but got ${data}`, options);
+});
+function checkWithinRange(data, meta, description, options, skipMin = false) {
+	const { max = Infinity, min = -Infinity } = meta;
+	if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+	if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+}
+Schema.extend("string", (data, { meta }, options) => {
+	if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+	if (meta.pattern) {
+		const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+		if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+	}
+	checkWithinRange(data.length, meta, "string length", options);
+	return [data];
+});
+function decimalShift(data, digits) {
+	const str = data.toString();
+	if (str.includes("e")) return data * Math.pow(10, digits);
+	const index = str.indexOf(".");
+	if (index === -1) return data * Math.pow(10, digits);
+	const frac = str.slice(index + 1);
+	const integer = str.slice(0, index);
+	if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+	return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+}
+function isMultipleOf(data, min, step) {
+	step = Math.abs(step);
+	if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+	const index = step.toString().indexOf(".");
+	const digits = step.toString().slice(index + 1).length;
+	return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+}
+Schema.extend("number", (data, { meta }, options) => {
+	if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+	checkWithinRange(data, meta, "number", options);
+	const { step } = meta;
+	if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+	return [data];
+});
+Schema.extend("boolean", (data, _, options) => {
+	if (typeof data === "boolean") return [data];
+	throw new ValidationError(`expected boolean but got ${data}`, options);
+});
+Schema.extend("bitset", (data, { bits, meta }, options) => {
+	let value = 0, keys = [];
+	if (typeof data === "number") {
+		value = data;
+		for (const key in bits) if (data & bits[key]) keys.push(key);
+	} else if (Array.isArray(data)) {
+		keys = data;
+		for (const key of keys) {
+			if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+			if (key in bits) value |= bits[key];
+		}
+	} else throw new ValidationError(`expected number or array but got ${data}`, options);
+	if (value === meta.default) return [value];
+	return [value, keys];
+});
+Schema.extend("function", (data, _, options) => {
+	if (typeof data === "function") return [data];
+	throw new ValidationError(`expected function but got ${data}`, options);
+});
+Schema.extend("is", (data, { constructor }, options) => {
+	if (typeof constructor === "function") {
+		if (data instanceof constructor) return [data];
+		throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+	} else {
+		if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+		let prototype = Object.getPrototypeOf(data);
+		while (prototype) {
+			if (prototype.constructor?.name === constructor) return [data];
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+	}
+});
+function property(data, key, schema, options) {
+	try {
+		const [value, adapted] = Schema.resolve(data[key], schema, {
+			...options,
+			path: [...options.path || [], key]
+		});
+		if (adapted !== void 0) data[key] = adapted;
+		return value;
+	} catch (e) {
+		if (!options?.autofix) throw e;
+		delete data[key];
+		return schema.meta.volatile ? createVolatile(schema.meta.default) : schema.meta.default;
+	}
+}
+Schema.extend("array", (data, { inner, meta }, options) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+	return [data.map((_, index) => property(data, index, inner, options))];
+});
+Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in data) {
+		let rKey;
+		try {
+			rKey = Schema.resolve(key, sKey, options)[0];
+		} catch (error) {
+			if (strict) continue;
+			throw error;
+		}
+		result[rKey] = property(data, key, inner, options);
+		data[rKey] = data[key];
+		if (key !== rKey) delete data[key];
+	}
+	return [result];
+});
+Schema.extend("tuple", (data, { list }, options, strict) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	const result = list.map((inner, index) => property(data, index, inner, options));
+	if (strict) return [result];
+	result.push(...data.slice(list.length));
+	return [result];
+});
+function merge(result, data) {
+	for (const key in data) {
+		if (key in result) continue;
+		result[key] = data[key];
+	}
+}
+Schema.extend("object", (data, { dict }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in dict) {
+		const value = property(data, key, dict[key], options);
+		if (!isNullable(value) || key in data) result[key] = value;
+	}
+	if (!strict) merge(result, data);
+	return [result];
+});
+Schema.extend("union", (data, { list, toString }, options, strict) => {
+	const messages = [];
+	for (const inner of list) try {
+		return Schema.resolve(data, inner, options, strict);
+	} catch (error) {
+		messages.push(error);
+	}
+	throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+	if (!list.length) return [data];
+	let result;
+	for (const inner of list) {
+		const value = Schema.resolve(data, inner, options, true)[0];
+		if (isNullable(value)) continue;
+		if (isNullable(result)) result = value;
+		else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		else if (typeof value === "object") merge(result ??= {}, value);
+		else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+	}
+	if (!strict && isPlainObject(data)) merge(result, data);
+	return [result];
+});
+Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+	const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+	if (preserve) return [callback(result)];
+	else return [callback(result), callback(adapted)];
+});
+const formatters = {};
+function defineMethod(name, keys, format) {
+	formatters[name] = format;
+	Object.assign(Schema, { [name](...args) {
+		const schema = new Schema({ type: name });
+		keys.forEach((key, index) => {
+			switch (key) {
+				case "sKey":
+					schema.sKey = args[index] ?? Schema.string();
+					break;
+				case "inner":
+					schema.inner = Schema.from(args[index]);
+					break;
+				case "list":
+					schema.list = args[index].map(Schema.from);
+					break;
+				case "dict":
+					schema.dict = mapValues(args[index], Schema.from);
+					break;
+				case "bits":
+					schema.bits = {};
+					for (const key in args[index]) {
+						if (typeof args[index][key] !== "number") continue;
+						schema.bits[key] = args[index][key];
+					}
+					break;
+				case "callback": {
+					const callback = schema.callback = args[index];
+					callback["toJSON"] ||= () => callback.toString();
+					break;
+				}
+				case "constructor": {
+					const constructor = schema.constructor = args[index];
+					if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+					break;
+				}
+				default: schema[key] = args[index];
+			}
+		});
+		if (name === "object" || name === "dict") schema.meta.default = {};
+		else if (name === "array" || name === "tuple") schema.meta.default = [];
+		else if (name === "bitset") schema.meta.default = 0;
+		return schema;
+	} });
+}
+defineMethod("is", ["constructor"], ({ constructor }) => {
+	if (typeof constructor === "function") return constructor.name;
+	else return constructor;
+});
+defineMethod("any", [], () => "any");
+defineMethod("never", [], () => "never");
+defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+defineMethod("string", [], () => "string");
+defineMethod("number", [], () => "number");
+defineMethod("boolean", [], () => "boolean");
+defineMethod("bitset", ["bits"], () => "bitset");
+defineMethod("function", [], () => "function");
+defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+defineMethod("object", ["dict"], ({ dict }) => {
+	if (Object.keys(dict).length === 0) return "{}";
+	return `{ ${Object.entries(dict).map(([key, inner]) => {
+		return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+	}).join(", ")} }`;
+});
+defineMethod("union", ["list"], ({ list }, inline) => {
+	const result = list.map(({ toString: format }) => format()).join(" | ");
+	return inline ? `(${result})` : result;
+});
+defineMethod("intersect", ["list"], ({ list }) => {
+	return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+});
+defineMethod("transform", [
+	"inner",
+	"callback",
+	"preserve"
+], ({ inner }, isInner) => inner.toString(isInner));
+// src/protocol.ts
+const channel = "/api";
+const endpointPrefix = "dungsil-cli-proxy-api/";
+const providerFamilies = [
+	"gemini",
+	"interactions",
+	"codex",
+	"meta",
+	"xai",
+	"claude",
+	"vertex",
+	"openai-compatibility"
+];
+const oauthProviders = [
+	"claude",
+	"codex",
+	"antigravity",
+	"kimi",
+	"kimi-ai",
+	"xai",
+	"devin",
+	"meta"
+];
+// src/quota.ts
+function fail(code) {
+	throw new Error(code);
+}
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function text$1(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function encoded(value) {
+	try {
+		return encodeURIComponent(value);
+	} catch {
+		fail("invalid");
+	}
+}
+function jsonRecord(value) {
+	if (typeof value === "string") try {
+		value = JSON.parse(value);
+	} catch {
+		fail("invalid_response");
+	}
+	if (value === null || typeof value !== "object" || Array.isArray(value)) fail("invalid_response");
+	return value;
+}
+function number(value) {
+	if (typeof value !== "number" && (typeof value !== "string" || !value.trim())) return;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function percent(value) {
+	const parsed = number(value);
+	return parsed !== void 0 && parsed >= 0 && parsed <= 100 ? parsed : void 0;
+}
+function positive(value) {
+	const parsed = number(value);
+	return parsed !== void 0 && parsed > 0 ? parsed : void 0;
+}
+function instant(value) {
+	const seconds = number(value);
+	const ms = seconds !== void 0 ? seconds * 1e3 : typeof value === "string" && /^\d{4}-\d{2}-\d{2}T/.test(value) ? Date.parse(value) : NaN;
+	return Number.isFinite(ms) && ms >= 0 && Number.isFinite(new Date(ms).getTime()) ? new Date(ms).toISOString() : void 0;
+}
+function planName(value) {
+	const name = text$1(value);
+	return name && name.length <= 64 && /^[\p{L}\p{N} _+().-]+$/u.test(name) ? name : void 0;
+}
+function provider$1(account) {
+	const key = text$1(account.provider ?? account.type).toLowerCase().replace(/_/g, "-");
+	if (key === "kimi-ai") return "kimi";
+	if (key === "grok" || key === "x-ai") return "xai";
+	return key;
+}
+function pluginId(account) {
+	const supported = account.supports_quota ?? account.supportsQuota;
+	return supported === true || supported === "true" || supported === "1" ? text$1(account.quota_plugin_id ?? account.quotaPluginId) : "";
+}
+function supportsQuota(account) {
+	const disabled = account.disabled;
+	if (disabled === true || typeof disabled === "number" && disabled !== 0 || ["true", "1"].includes(text$1(disabled).toLowerCase())) return false;
+	return [
+		"claude",
+		"codex",
+		"antigravity",
+		"kimi",
+		"devin",
+		"meta",
+		"xai"
+	].includes(provider$1(account)) || Boolean(pluginId(account));
+}
+async function managementCall(management, path, method = "GET", body) {
+	try {
+		return await management(path, method, body);
+	} catch {
+		fail("upstream_failed");
+	}
+}
+async function download(account, management) {
+	const name = text$1(account.name);
+	if (!name || [account.runtimeOnly, account.runtime_only].some((value) => value === true || value === "true")) fail("invalid");
+	return jsonRecord(await managementCall(management, `credentials/download?name=${encoded(name)}`));
+}
+async function apiCall(management, authIndex, url, header, data) {
+	const response = record$1(await managementCall(management, "requests/api-call", "POST", {
+		auth_index: authIndex,
+		method: data === void 0 ? "GET" : "POST",
+		url,
+		header,
+		...data === void 0 ? {} : { data: JSON.stringify(data) }
+	}));
+	if (typeof response.status_code !== "number" || !Number.isInteger(response.status_code)) fail("invalid_response");
+	if (response.status_code < 200 || response.status_code >= 300) fail("upstream_failed");
+	if (typeof response.body !== "string") fail("invalid_response");
+	return jsonRecord(response.body);
+}
+function addWindow(windows, id, used, reset, duration) {
+	if (windows.length >= 100) return;
+	const usedPercent = percent(used);
+	const resetAt = instant(reset);
+	const periodSeconds = positive(duration);
+	if (usedPercent === void 0 && resetAt === void 0 && periodSeconds === void 0) return;
+	windows.push({
+		id,
+		...usedPercent === void 0 ? {} : { usedPercent },
+		...resetAt === void 0 ? {} : { resetAt },
+		...periodSeconds === void 0 ? {} : { periodSeconds }
+	});
+}
+function fromRemaining(value, scale) {
+	const remaining = number(value);
+	return remaining !== void 0 && remaining >= 0 && remaining <= scale ? 100 - remaining / scale * 100 : void 0;
+}
+function groupWindows(payload, windows) {
+	if (payload.groups !== void 0 && !Array.isArray(payload.groups)) fail("invalid_response");
+	if (!Array.isArray(payload.groups)) return;
+	for (const [groupIndex, group] of payload.groups.entries()) {
+		const buckets = record$1(group).buckets;
+		if (!Array.isArray(buckets)) continue;
+		for (const [bucketIndex, value] of buckets.entries()) {
+			const bucket = record$1(value);
+			const window = text$1(bucket.window).toLowerCase();
+			const duration = [
+				"5h",
+				"five-hour",
+				"five_hour"
+			].includes(window) ? 18e3 : ["weekly", "week"].includes(window) ? 604800 : void 0;
+			addWindow(windows, [planName(record$1(group).displayName ?? record$1(group).display_name), planName(bucket.displayName ?? bucket.display_name) ?? planName(bucket.window)].filter(Boolean).join(" ").slice(0, 96) || `group-${groupIndex + 1}-bucket-${bucketIndex + 1}`, fromRemaining(bucket.remainingFraction ?? bucket.remaining_fraction, 1), bucket.resetTime ?? bucket.reset_time, duration);
+			if (windows.length >= 100) return;
+		}
+	}
+}
+function codexAccountId(account) {
+	const sources = [
+		account,
+		record$1(account.metadata),
+		record$1(account.attributes)
+	];
+	for (const source of sources) {
+		const direct = text$1(source.chatgpt_account_id ?? source.chatgptAccountId);
+		if (direct && !/[\r\n]/.test(direct)) return direct;
+	}
+	for (const source of sources) {
+		let token = source.id_token;
+		if (typeof token === "string") {
+			const rawToken = token;
+			try {
+				token = JSON.parse(token);
+			} catch {
+				try {
+					token = JSON.parse(Buffer.from(rawToken.split(".")[1] ?? "", "base64url").toString("utf8"));
+				} catch {
+					continue;
+				}
+			}
+		}
+		const claims = record$1(token);
+		const auth = record$1(claims["https://api.openai.com/auth"]);
+		const id = text$1(claims.chatgpt_account_id ?? claims.chatgptAccountId ?? auth.chatgpt_account_id);
+		if (id && !/[\r\n]/.test(id)) return id;
+	}
+	return "";
+}
+function codexWindows(payload, windows, now) {
+	const limits = [["", payload.rate_limit ?? payload.rateLimit], ["code_review_", payload.code_review_rate_limit ?? payload.codeReviewRateLimit]];
+	const additional = payload.additional_rate_limits ?? payload.additionalRateLimits;
+	if (Array.isArray(additional)) additional.slice(0, 50).forEach((value, i) => {
+		const item = record$1(value);
+		const name = planName(item.limit_name ?? item.limitName ?? item.metered_feature ?? item.meteredFeature);
+		limits.push([`${name ?? `additional-${i + 1}`} `, item.rate_limit ?? item.rateLimit]);
+	});
+	for (const [prefix, value] of limits) {
+		const limit = record$1(value);
+		for (const [position, raw] of [limit.primary_window ?? limit.primaryWindow, limit.secondary_window ?? limit.secondaryWindow].entries()) {
+			const window = record$1(raw);
+			const duration = positive(window.limit_window_seconds ?? window.limitWindowSeconds);
+			const id = position === 0 ? "primary_window" : "secondary_window";
+			const offset = number(window.reset_after_seconds ?? window.resetAfterSeconds);
+			const reset = instant(window.reset_at ?? window.resetAt) ?? (offset !== void 0 && offset >= 0 ? instant(now / 1e3 + offset) : void 0);
+			addWindow(windows, `${prefix}${id}`, window.used_percent ?? window.usedPercent, reset, duration);
+		}
+	}
+}
+function kimiDomain(value, isUrl = false) {
+	let domain = text$1(value).toLowerCase();
+	if (isUrl) try {
+		domain = new URL(domain).hostname;
+	} catch {
+		return;
+	}
+	if ([
+		"ai",
+		"kimi-ai",
+		"kimi_ai",
+		"kimi.ai"
+	].includes(domain) || domain.endsWith(".kimi.ai")) return "ai";
+	if ([
+		"com",
+		"kimi",
+		"kimi.com"
+	].includes(domain) || domain.endsWith(".kimi.com")) return "com";
+}
+function kimiWindows(payload, windows, now) {
+	const rows = [];
+	if (Array.isArray(payload.limits)) payload.limits.slice(0, 100).forEach((value, i) => {
+		const item = record$1(value);
+		const detail = record$1(item.detail ?? item);
+		const name = planName(item.displayName ?? item.name ?? item.title ?? detail.name ?? detail.title);
+		rows.push([
+			name ?? `limit-${i + 1}`,
+			detail,
+			item
+		]);
+	});
+	if (payload.usage) rows.push([
+		"weekly",
+		record$1(payload.usage),
+		{}
+	]);
+	for (const [id, detail, item] of rows) {
+		const limit = positive(detail.limit);
+		const remaining = number(detail.remaining);
+		const used = number(detail.used) ?? (limit !== void 0 && remaining !== void 0 ? limit - remaining : void 0);
+		const offset = number(detail.reset_in ?? detail.resetIn ?? detail.ttl);
+		const reset = instant(detail.reset_at ?? detail.resetAt ?? detail.reset_time ?? detail.resetTime) ?? (offset !== void 0 && offset >= 0 ? instant(now / 1e3 + offset) : void 0);
+		const window = record$1(item.window);
+		const duration = positive(window.duration ?? item.duration ?? detail.duration);
+		const unit = text$1(window.timeUnit ?? item.timeUnit ?? detail.timeUnit).toUpperCase().replace(/^TIME_UNIT_/, "");
+		const multiplier = /^SECONDS?$/.test(unit) ? 1 : /^HOURS?$/.test(unit) ? 3600 : /^DAYS?$/.test(unit) ? 86400 : /^WEEKS?$/.test(unit) ? 604800 : 60;
+		addWindow(windows, id, limit !== void 0 && used !== void 0 ? used / limit * 100 : void 0, reset, duration === void 0 ? void 0 : duration * multiplier);
+	}
+	const monthly = record$1(record$1(payload.usages).limit_month_total);
+	const ratio = number(monthly.used_ratio);
+	addWindow(windows, "monthly", ratio === void 0 ? void 0 : ratio * 100, monthly.reset_time);
+}
+async function fetchQuota(account, management) {
+	if (!supportsQuota(account)) fail("unsupported");
+	const rawIndex = account.auth_index ?? account.authIndex;
+	const authIndex = typeof rawIndex === "number" && Number.isFinite(rawIndex) ? String(rawIndex) : text$1(rawIndex);
+	if (!authIndex) fail("invalid");
+	const windows = [];
+	const now = Date.now();
+	let plan;
+	const kind = provider$1(account);
+	const bearer = { Authorization: "Bearer $TOKEN$" };
+	const jsonHeaders = {
+		...bearer,
+		"Content-Type": "application/json"
+	};
+	const id = pluginId(account);
+	if (id) {
+		const payload = jsonRecord(await managementCall(management, `plugins/${encoded(id)}/quota`, "POST", { auth_index: authIndex }));
+		groupWindows(payload, windows);
+		const subscription = record$1(payload.subscription);
+		plan = planName(subscription.plan ?? subscription.tierName ?? subscription.tierId);
+	} else if (kind === "claude") {
+		const payload = await apiCall(management, authIndex, "https://api.anthropic.com/api/oauth/usage", {
+			...jsonHeaders,
+			Accept: "application/json",
+			"anthropic-beta": "oauth-2025-04-20",
+			"User-Agent": "claude-cli/2.1.280 (external, cli)"
+		});
+		for (const key of [
+			"five_hour",
+			"seven_day",
+			"seven_day_oauth_apps",
+			"seven_day_opus",
+			"seven_day_sonnet",
+			"seven_day_cowork",
+			"iguana_necktie"
+		]) {
+			if (payload[key] === null || typeof payload[key] !== "object" || Array.isArray(payload[key])) continue;
+			const window = record$1(payload[key]);
+			addWindow(windows, key === "iguana_necktie" ? "credits" : key, window.utilization, window.resets_at, key === "five_hour" ? 18e3 : key === "iguana_necktie" ? void 0 : 604800);
+		}
+		plan = planName(payload.plan_type);
+	} else if (kind === "codex") {
+		const accountId = codexAccountId(account);
+		const payload = await apiCall(management, authIndex, "https://chatgpt.com/backend-api/wham/usage", {
+			...jsonHeaders,
+			"User-Agent": "codex-tui/0.149.1 (Mac OS 26.5.2; arm64) iTerm.app/3.6.11 (codex-tui; 0.149.1)",
+			...accountId ? { "Chatgpt-Account-Id": accountId } : {}
+		});
+		codexWindows(payload, windows, now);
+		plan = planName(payload.plan_type ?? payload.planType);
+	} else if (kind === "antigravity") {
+		const metadata = record$1(account.metadata);
+		const attributes = record$1(account.attributes);
+		let project = text$1(account.project_id ?? account.projectId) || text$1(metadata.project_id ?? metadata.projectId) || text$1(attributes.project_id ?? attributes.projectId ?? attributes.gemini_virtual_project);
+		if (!project) {
+			const credential = await download(account, management);
+			project = text$1(credential.project_id ?? credential.projectId) || text$1(record$1(credential.installed).project_id ?? record$1(credential.installed).projectId) || text$1(record$1(credential.web).project_id ?? record$1(credential.web).projectId);
+		}
+		if (!project) fail("invalid");
+		let payload;
+		let lastCode = "upstream_failed";
+		for (const host of [
+			"daily-cloudcode-pa.googleapis.com",
+			"daily-cloudcode-pa.sandbox.googleapis.com",
+			"cloudcode-pa.googleapis.com"
+		]) try {
+			payload = await apiCall(management, authIndex, `https://${host}/v1internal:retrieveUserQuotaSummary`, {
+				...jsonHeaders,
+				"User-Agent": "antigravity/hub/2.23.0 darwin/arm64"
+			}, { project });
+			if (!Array.isArray(payload.groups)) fail("invalid_response");
+			break;
+		} catch (error) {
+			payload = void 0;
+			lastCode = error instanceof Error && error.message === "invalid_response" ? "invalid_response" : "upstream_failed";
+		}
+		if (!payload) fail(lastCode);
+		groupWindows(payload, windows);
+		plan = planName(record$1(payload.subscription).plan);
+	} else if (kind === "kimi") {
+		const credential = await download(account, management);
+		const explicit = text$1(credential.domain);
+		kimiWindows(await apiCall(management, authIndex, `https://api.kimi.${(explicit ? kimiDomain(explicit) ?? "com" : void 0) ?? kimiDomain(Object.hasOwn(credential, "base_url") ? credential.base_url : credential["base-url"], true) ?? kimiDomain(credential.type) ?? kimiDomain(account.provider ?? account.type) ?? "com"}/coding/v1/usages`, bearer), windows, now);
+	} else if (kind === "devin") {
+		const status = record$1(record$1((await apiCall(management, authIndex, "https://server.codeium.com/exa.seat_management_pb.SeatManagementService/GetUserStatus", {
+			"Content-Type": "application/json",
+			"Connect-Protocol-Version": "1"
+		}, { metadata: {
+			ideName: "chisel",
+			ideVersion: "3000.10.21",
+			apiKey: "$TOKEN$",
+			locale: "en",
+			os: "darwin",
+			extensionVersion: "3000.10.21",
+			clientName: "chisel"
+		} })).userStatus).planStatus);
+		for (const id of ["daily", "weekly"]) {
+			if (!Object.hasOwn(status, `${id}QuotaRemainingPercent`) && !Object.hasOwn(status, `${id}QuotaResetAtUnix`)) continue;
+			addWindow(windows, id, fromRemaining(status[`${id}QuotaRemainingPercent`], 100), status[`${id}QuotaResetAtUnix`], id === "daily" ? 86400 : 604800);
+		}
+		plan = planName(record$1(status.planInfo).planName);
+	} else if (kind === "meta") {
+		const token = text$1((await download(account, management)).dca_token);
+		if (!/^dca:[^\s]+$/.test(token)) fail("invalid");
+		const payload = await apiCall(management, authIndex, "https://api.meta.ai/muse-code/key", {
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${token}`,
+			"x-api-version": "1.0.0"
+		}, {});
+		const usage = record$1(payload.subs_usage);
+		for (const id of ["window", "weekly"]) {
+			const window = record$1(usage[id]);
+			const minutes = positive(window.window_duration_mins);
+			addWindow(windows, id === "window" ? "primary_window" : id, window.used_percent, window.resets_at, id === "window" && minutes !== void 0 ? minutes * 60 : void 0);
+		}
+		plan = planName(payload.subs_tier_name ?? usage.tier);
+	} else if (kind === "xai") {
+		const header = {
+			...bearer,
+			"x-xai-token-auth": "xai-grok-cli",
+			"x-grok-client-version": "1.0.46",
+			accept: "*/*",
+			"user-agent": "grok-pager/1.0.46 grok-shell/1.0.46 (macos; aarch64)"
+		};
+		const userId = [
+			account,
+			record$1(account.metadata),
+			record$1(account.attributes)
+		].map((source) => text$1(source.sub ?? source.subject ?? source.user_id ?? source.userId) || text$1(record$1(source.oauth).sub ?? record$1(source.oauth).subject) || text$1(record$1(source.user).sub ?? record$1(source.user).id)).find(Boolean);
+		if (userId && !/[\r\n]/.test(userId)) header["x-userid"] = userId;
+		const results = await Promise.allSettled([apiCall(management, authIndex, "https://cli-chat-proxy.grok.com/v1/billing?format=credits", header), apiCall(management, authIndex, "https://cli-chat-proxy.grok.com/v1/billing", header)]);
+		if (results.every((result) => result.status === "rejected")) fail(results.some((result) => result.status === "rejected" && result.reason instanceof Error && result.reason.message === "invalid_response") ? "invalid_response" : "upstream_failed");
+		for (const [i, result] of results.entries()) {
+			if (result.status !== "fulfilled") continue;
+			const config = record$1(result.value.config);
+			const period = record$1(config.currentPeriod ?? config.current_period);
+			const end = period.end ?? config.billingPeriodEnd ?? config.billing_period_end;
+			const startAt = instant(period.start ?? config.billingPeriodStart ?? config.billing_period_start);
+			const endAt = instant(end);
+			const duration = startAt && endAt ? (Date.parse(endAt) - Date.parse(startAt)) / 1e3 : void 0;
+			const limitValue = config.monthlyLimit ?? config.monthly_limit;
+			const limit = positive(record$1(limitValue).val ?? limitValue);
+			const used = number(record$1(config.used).val ?? config.used);
+			const credit = config.creditUsagePercent ?? config.credit_usage_percent;
+			addWindow(windows, i === 0 ? [
+				"daily",
+				"weekly",
+				"monthly"
+			].includes(text$1(period.type)) ? text$1(period.type) : "credits" : "monthly", i === 0 ? credit : limit !== void 0 && used !== void 0 ? used / limit * 100 : void 0, end, duration);
+		}
+	}
+	return {
+		windows,
+		observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...plan ? { plan } : {}
+	};
+}
+// src/index.ts
+const name = "dungsil-cli-proxy-api";
+const inject = [
+	"connection",
+	"configEditor",
+	"credentials",
+	"llm"
+];
+const provider = "cli-proxy-api";
+const Config = Schema.object({
+	baseURL: Schema.string().default("http://127.0.0.1:8317").volatile(),
+	revision: Schema.string().default("").volatile()
+});
+function serverURL(value) {
+	const url = new URL(value);
+	const loopback = [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname);
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback) || url.username || url.password || url.search || url.hash) throw new Error("invalid");
+	return url.href.replace(/\/+$/, "");
+}
+function keyRef(baseURL, kind) {
+	return credentialRef(`DSH_CLIPROXY_${kind.toUpperCase()}_${createHash("sha256").update(baseURL).digest("hex")}`);
+}
+function record(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid_response");
+	return value;
+}
+function text(value, max = 1024) {
+	if (typeof value !== "string" || !value.trim() || value.length > max) throw new Error("invalid");
+	return value;
+}
+function apply(ctx, config) {
+	let busy = false;
+	const sessions = /* @__PURE__ */ new Map();
+	const lifetime = new AbortController();
+	ctx.effect(() => () => lifetime.abort());
+	const currentURL = () => serverURL(config.baseURL.get());
+	const ownerEntry = () => {
+		const entries = ctx.configEditor.entries().filter((entry) => entry.fiber === ctx.fiber);
+		if (entries.length !== 1) throw new Error("unavailable");
+		return entries[0];
+	};
+	const adapterEntry = () => {
+		const entries = ctx.configEditor.entries().filter((entry) => entry.options.name === "@deepseek-ai/dsh-llm-pi-ai" && entry.fiber?.state === 2);
+		if (entries.length !== 1) throw new Error("unavailable");
+		return entries[0];
+	};
+	const revision = () => createHash("sha256").update(JSON.stringify(ownerEntry().options.config ?? {})).digest("hex");
+	const describe = async () => {
+		const baseURL = currentURL();
+		const [api, management] = await Promise.all(["api", "management"].map((kind) => ctx.credentials.describe(keyRef(baseURL, kind))));
+		return {
+			baseURL,
+			revision: revision(),
+			apiKeySaved: api.configured,
+			managementKeySaved: management.configured
+		};
+	};
+	const request = async (baseURL, path, kind, signal, method = "GET", body, ifMatch) => {
+		const key = (await ctx.credentials.resolve(keyRef(baseURL, kind)))?.value;
+		if (!key) throw new Error(kind === "management" ? "management_key_missing" : "api_key_missing");
+		const response = await fetch(`${baseURL}${path}`, {
+			method,
+			redirect: "error",
+			signal: AbortSignal.any([
+				signal,
+				lifetime.signal,
+				AbortSignal.timeout(15e3)
+			]),
+			headers: {
+				Authorization: `Bearer ${key}`,
+				...ifMatch ? { "If-Match": ifMatch } : {},
+				...body === void 0 ? {} : { "Content-Type": "application/json" }
+			},
+			...body === void 0 ? {} : { body: JSON.stringify(body) }
+		});
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new Error(response.status === 401 || response.status === 403 ? "unauthorized" : response.status === 412 ? "conflict" : response.status === 404 ? "not_found" : "upstream_failed");
+		}
+		if (!response.body) throw new Error("invalid_response");
+		const reader = response.body.getReader();
+		const chunks = [];
+		let size = 0;
+		try {
+			while (true) {
+				const next = await reader.read();
+				if (next.done) break;
+				size += next.value.byteLength;
+				if (size > 4194304) throw new Error("invalid_response");
+				chunks.push(next.value);
+			}
+			return {
+				data: JSON.parse(Buffer.concat(chunks).toString("utf8")),
+				etag: response.headers.get("ETag")
+			};
+		} finally {
+			await reader.cancel().catch(() => {});
+		}
+	};
+	const syncModels = async (baseURL, models) => {
+		const entry = adapterEntry();
+		await ctx.configEditor.edit(entry, (current) => {
+			const providers = { ...current.providers };
+			const previous = providers[provider];
+			if (!models?.length) delete providers[provider];
+			else {
+				const matching = previous?.baseURL === `${baseURL}/v1` ? previous : void 0;
+				providers[provider] = {
+					...matching,
+					displayName: "CLIProxyAPI",
+					api: "openai-completions",
+					baseURL: `${baseURL}/v1`,
+					apiKeyEnv: keyRef(baseURL, "api"),
+					models: models.map((model) => ({
+						...matching?.models?.find((item) => item.id === model.id),
+						...model
+					}))
+				};
+			}
+			return {
+				...current,
+				providers
+			};
+		});
+	};
+	const handle = async (endpoint, payload, signal) => {
+		if (endpoint === "describe") return describe();
+		const input = record(payload);
+		const baseURL = currentURL();
+		const management = async (path, method = "GET", body) => (await request(baseURL, `/v8/management/${path}`, "management", signal, method, body)).data;
+		if (endpoint === "providers" || endpoint === "provider-add") {
+			const snapshot = await request(baseURL, "/v8/management/config", "management", signal);
+			if (!snapshot.etag) throw new Error("unavailable");
+			const families = record(record(snapshot.data)["api-keys"] ?? {});
+			if (endpoint === "providers") {
+				const groups = [];
+				for (const family of providerFamilies) {
+					const rows = families[family] ?? [];
+					if (!Array.isArray(rows)) throw new Error("invalid_response");
+					for (const value of rows) {
+						const row = record(value);
+						if (!Array.isArray(row.keys)) throw new Error("invalid_response");
+						groups.push({
+							family,
+							name: text(row.name),
+							keys: row.keys.length
+						});
+					}
+				}
+				return {
+					revision: snapshot.etag,
+					groups
+				};
+			}
+			if (input.revision !== snapshot.etag) throw new Error("conflict");
+			const family = text(input.family);
+			if (!providerFamilies.includes(family)) throw new Error("invalid");
+			const name = text(input.name, 256).trim();
+			const apiKey = text(input.apiKey, 16384).trim();
+			if (/[\r\n\0]/.test(apiKey)) throw new Error("invalid");
+			const upstreamURL = typeof input.baseURL === "string" && input.baseURL.trim() ? serverURL(input.baseURL.trim()) : void 0;
+			if (!Array.isArray(input.models) || input.models.length > 500) throw new Error("invalid");
+			const models = [...new Set(input.models.map((model) => text(model, 256).trim()))];
+			if (family === "openai-compatibility" && (!upstreamURL || models.length === 0)) throw new Error("invalid");
+			const groups = families[family] ?? [];
+			if (!Array.isArray(groups)) throw new Error("invalid_response");
+			if (groups.some((group) => record(group).name === name)) throw new Error("conflict");
+			await request(baseURL, `/v8/management/config/api-keys/${family}`, "management", signal, "PUT", [...groups, {
+				name,
+				...upstreamURL ? { "base-url": upstreamURL } : {},
+				keys: [{ "api-key": apiKey }],
+				...models.length ? { models: models.map((id) => ({
+					name: id,
+					alias: id
+				})) } : {}
+			}], snapshot.etag);
+			return null;
+		}
+		if (endpoint === "save") {
+			if (input.revision !== revision()) throw new Error("conflict");
+			const nextURL = serverURL(text(input.baseURL, 4096));
+			for (const kind of ["apiKey", "managementKey"]) {
+				const value = input[kind];
+				if (value !== void 0 && (typeof value !== "string" || value.length > 16384 || /[\r\n\0]/.test(value))) throw new Error("invalid");
+			}
+			const owner = ownerEntry();
+			if (nextURL !== baseURL || typeof input.apiKey === "string" && !input.apiKey.trim()) await syncModels(baseURL);
+			for (const [field, kind] of [["apiKey", "api"], ["managementKey", "management"]]) {
+				const value = input[field];
+				if (value === void 0 && nextURL === baseURL) continue;
+				const ref = keyRef(nextURL, kind);
+				if (typeof value === "string" && value.trim()) await ctx.credentials.set(ref, value.trim());
+				else await ctx.credentials.unset(ref);
+			}
+			signal.throwIfAborted();
+			await ctx.configEditor.edit(owner, (current) => {
+				if (input.revision !== revision()) throw new Error("conflict");
+				return {
+					...current,
+					baseURL: nextURL,
+					revision: randomUUID()
+				};
+			});
+			sessions.clear();
+			return null;
+		}
+		if (endpoint === "models") {
+			const response = record((await request(baseURL, "/v1/models", "api", signal)).data);
+			if (!Array.isArray(response.data)) throw new Error("invalid_response");
+			const models = /* @__PURE__ */ new Map();
+			for (const item of response.data) {
+				const row = record(item);
+				const id = text(row.id);
+				models.set(id, {
+					id,
+					name: typeof row.name === "string" && row.name.trim() ? row.name : id
+				});
+			}
+			signal.throwIfAborted();
+			await syncModels(baseURL, [...models.values()]);
+			return [...models.values()];
+		}
+		if (endpoint === "quota-list" || endpoint === "quota-fetch") {
+			const getAccounts = async () => {
+				const files = record(await management("credentials")).files;
+				if (!Array.isArray(files)) throw new Error("invalid_response");
+				return files.map(record);
+			};
+			const accounts = await getAccounts();
+			if (endpoint === "quota-list") return accounts.map((row) => ({
+				name: text(row.name),
+				provider: typeof row.provider === "string" ? row.provider : typeof row.type === "string" ? row.type : "",
+				status: "",
+				disabled: row.disabled === true,
+				authIndex: typeof row.auth_index === "string" ? row.auth_index : "",
+				editable: row.source === "file" && row.runtime_only !== true,
+				supported: supportsQuota(row)
+			}));
+			const find = (rows) => rows.find((row) => row.name === text(input.name) && row.auth_index === text(input.authIndex));
+			const account = find(accounts);
+			if (!account || account.disabled === true) throw new Error("conflict");
+			const connectionRevision = revision();
+			const result = await fetchQuota(account, management);
+			const current = find(await getAccounts());
+			if (revision() !== connectionRevision || !current || current.disabled === true || current.provider !== account.provider || current.type !== account.type || current.modtime !== account.modtime || current.updated_at !== account.updated_at) throw new Error("conflict");
+			return result;
+		}
+		if (endpoint === "management") {
+			const files = record(await management("credentials")).files;
+			const routing = record(await management("config/routing"));
+			if (!Array.isArray(files)) throw new Error("invalid_response");
+			const retry = record(routing.retry ?? {})["request-retry"] ?? 3;
+			if (typeof routing.strategy !== "string" || !Number.isInteger(retry)) throw new Error("invalid_response");
+			return {
+				accounts: files.map((item) => {
+					const row = record(item);
+					return {
+						name: text(row.name),
+						provider: typeof row.provider === "string" ? row.provider : "",
+						status: typeof row.status === "string" ? row.status : "",
+						disabled: row.disabled === true,
+						authIndex: typeof row.auth_index === "string" ? row.auth_index : "",
+						editable: row.source === "file" && row.runtime_only !== true
+					};
+				}),
+				strategy: routing.strategy,
+				requestRetry: retry
+			};
+		}
+		if (endpoint === "routing") {
+			if (![
+				"round-robin",
+				"weighted-round-robin",
+				"fill-first"
+			].includes(String(input.strategy)) || typeof input.requestRetry !== "number" || !Number.isSafeInteger(input.requestRetry) || input.requestRetry < 0) throw new Error("invalid");
+			await management("config/routing", "PATCH", {
+				strategy: input.strategy,
+				retry: { "request-retry": input.requestRetry }
+			});
+			return null;
+		}
+		if (endpoint === "account") {
+			if (typeof input.disabled !== "boolean") throw new Error("invalid");
+			await management("credentials/status", "PATCH", {
+				name: text(input.name),
+				disabled: input.disabled
+			});
+			return null;
+		}
+		if (endpoint === "reset") {
+			await management("routing/cooldown/reset", "POST", { auth_index: text(input.authIndex) });
+			return null;
+		}
+		if (endpoint === "oauth-start") {
+			const selected = text(input.provider);
+			if (!oauthProviders.includes(selected)) throw new Error("invalid");
+			for (const [state, session] of sessions) if (session.expires <= Date.now()) sessions.delete(state);
+			if (sessions.size >= 10) throw new Error("busy");
+			const response = record(await management(`oauth/auth-url?provider=${encodeURIComponent(selected)}&is_webui=true`));
+			const state = text(response.state);
+			const url = new URL(text(response.url, 16384));
+			if (url.protocol !== "https:" || url.username || url.password) throw new Error("invalid_response");
+			sessions.set(state, {
+				provider: selected,
+				baseURL,
+				expires: Date.now() + 18e5
+			});
+			return {
+				provider: selected,
+				state,
+				url: url.href,
+				...typeof response.user_code === "string" ? { userCode: response.user_code } : {}
+			};
+		}
+		if ([
+			"oauth-status",
+			"oauth-cancel",
+			"oauth-callback"
+		].includes(endpoint)) {
+			const state = text(input.state);
+			const session = sessions.get(state);
+			if (!session || session.baseURL !== baseURL || session.expires <= Date.now()) throw new Error("oauth_expired");
+			if (endpoint === "oauth-cancel") {
+				await management(`oauth/session?state=${encodeURIComponent(state)}`, "DELETE");
+				sessions.delete(state);
+				return null;
+			}
+			if (endpoint === "oauth-callback") {
+				if (input.provider !== session.provider) throw new Error("invalid");
+				const redirect = new URL(text(input.redirectURL, 16384));
+				if (!["http:", "https:"].includes(redirect.protocol) || redirect.searchParams.get("state") !== state) throw new Error("invalid");
+				await management("oauth/callback", "POST", {
+					provider: session.provider,
+					state,
+					redirect_url: redirect.href
+				});
+				return null;
+			}
+			const response = record(await management(`oauth/status?state=${encodeURIComponent(state)}`));
+			if (![
+				"wait",
+				"ok",
+				"error"
+			].includes(String(response.status))) throw new Error("invalid_response");
+			if (response.status !== "wait") sessions.delete(state);
+			return { status: response.status };
+		}
+		throw new Error("invalid");
+	};
+	const errors = /* @__PURE__ */ new Set([
+		"invalid",
+		"invalid_response",
+		"unavailable",
+		"conflict",
+		"api_key_missing",
+		"management_key_missing",
+		"unauthorized",
+		"not_found",
+		"upstream_failed",
+		"unsupported",
+		"oauth_expired",
+		"busy"
+	]);
+	for (const endpoint of [
+		"describe",
+		"save",
+		"models",
+		"management",
+		"providers",
+		"provider-add",
+		"quota-list",
+		"quota-fetch",
+		"routing",
+		"account",
+		"reset",
+		"oauth-start",
+		"oauth-status",
+		"oauth-cancel",
+		"oauth-callback"
+	]) ctx.effect(() => ctx.connection.fetch.register({
+		path: `${channel}/${endpointPrefix}${endpoint}`,
+		methods: ["POST"],
+		requestBody: "buffered",
+		async fetch(request) {
+			let body;
+			try {
+				body = clientRequestSchema.safeParse(await request.json());
+			} catch {
+				return new Response("Invalid request", { status: 400 });
+			}
+			if (!body.success || body.data.method !== `dungsil-cli-proxy-api/${endpoint}`) return new Response("Invalid request", { status: 400 });
+			let result;
+			if (busy) result = {
+				ok: false,
+				error: {
+					code: "busy",
+					message: "CLIProxyAPI operation in progress.",
+					details: {}
+				}
+			};
+			else {
+				busy = true;
+				try {
+					result = {
+						ok: true,
+						value: await handle(endpoint, body.data.payload, request.signal)
+					};
+				} catch (error) {
+					result = {
+						ok: false,
+						error: {
+							code: error instanceof Error && errors.has(error.message) ? error.message : "operation_failed",
+							message: "CLIProxyAPI operation could not be confirmed.",
+							details: {}
+						}
+					};
+				} finally {
+					busy = false;
+				}
+			}
+			return Response.json({
+				type: "server-response",
+				rpcId: body.data.rpcId,
+				result
+			}, { headers: { "Cache-Control": "no-store" } });
+		}
+	}), `cli-proxy-api: owner-only ${endpoint}`);
+}
+export { Config, apply, inject, name };