@kunkun.sh/kuota 0.0.0-stage → 0.1.0

package/dist/src-y_QKmTyj.mjs

@@ -0,0 +1,309 @@
+import { Schema } from "effect";
+// ../core/src/types.ts
+const ProviderIdSchema = Schema.Literal("codex", "claude", "antigravity");
+const QuotaStatusSchema = Schema.Literal("ok", "partial", "unauthenticated", "unavailable", "unsupported", "error");
+const QuotaWindowSchema = Schema.Struct({
+	windowId: Schema.String,
+	usedPercent: Schema.NullOr(Schema.Number),
+	remainingPercent: Schema.NullOr(Schema.Number),
+	resetAt: Schema.NullOr(Schema.String)
+});
+const QuotaSnapshotSchema = Schema.Struct({
+	provider: ProviderIdSchema,
+	status: QuotaStatusSchema,
+	fetchedAt: Schema.String,
+	source: Schema.String,
+	windows: Schema.Array(QuotaWindowSchema),
+	errorCode: Schema.NullOr(Schema.String)
+});
+// ../core/src/hash.ts
+const K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const rotr = (x, n) => x >>> n | x << 32 - n;
+/** Dependency-free SHA-256 (hex). Keeps @kuota/core free of node:crypto so it stays browser-safe. */
+function sha256Hex(text) {
+	const data = new TextEncoder().encode(text);
+	const bitLength = data.length * 8;
+	const padded = new Uint8Array(data.length + 9 + 63 >> 6 << 6);
+	padded.set(data);
+	padded[data.length] = 128;
+	const view = new DataView(padded.buffer);
+	view.setUint32(padded.length - 8, Math.floor(bitLength / 2 ** 32));
+	view.setUint32(padded.length - 4, bitLength >>> 0);
+	const h = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	const w = /* @__PURE__ */ new Uint32Array(64);
+	for (let offset = 0; offset < padded.length; offset += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+			const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+		}
+		let [a, b, c, d, e, f, g, hh] = h;
+		for (let i = 0; i < 64; i++) {
+			const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = hh + s1 + ch + K[i] + w[i] >>> 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		const next = [
+			a,
+			b,
+			c,
+			d,
+			e,
+			f,
+			g,
+			hh
+		];
+		for (let i = 0; i < 8; i++) h[i] = h[i] + next[i] >>> 0;
+	}
+	return Array.from(h, (x) => x.toString(16).padStart(8, "0")).join("");
+}
+// ../core/src/history/schema.ts
+const HOUR = 36e5;
+/**
+* Window cadence heuristics, derived from window ids the adapters emit. Only cadences named in
+* the id (5h / weekly / daily) are trusted; everything else stays `unknown` rather than guessed.
+* Codex `primary` / `secondary` follow the documented 5h / weekly convention of its app-server.
+*/
+function windowProfile(provider, windowId, resetAt, now = /* @__PURE__ */ new Date()) {
+	if (provider === "codex") {
+		if (windowId === "primary") {
+			if (resetAt) {
+				const resetMs = new Date(resetAt).getTime();
+				const nowMs = now.getTime();
+				if (Number.isFinite(resetMs) && resetMs - nowMs > 5 * HOUR) return {
+					semantics: "fixed",
+					durationMs: 168 * HOUR
+				};
+			}
+			return {
+				semantics: "fixed",
+				durationMs: 5 * HOUR
+			};
+		}
+		if (windowId === "secondary") return {
+			semantics: "fixed",
+			durationMs: 168 * HOUR
+		};
+	}
+	const id = windowId.toLowerCase();
+	const has = (re) => re.test(id);
+	if (has(/(^|[.:_-])(5h|five-hour)([.:_-]|$)/)) return {
+		semantics: "fixed",
+		durationMs: 5 * HOUR
+	};
+	if (has(/(^|[.:_-])(weekly|7d|seven-day)([.:_-]|$)/)) return {
+		semantics: "fixed",
+		durationMs: 168 * HOUR
+	};
+	if (has(/(^|[.:_-])(daily|24h)([.:_-]|$)/)) return {
+		semantics: "fixed",
+		durationMs: 24 * HOUR
+	};
+	return {
+		semantics: "unknown",
+		durationMs: null
+	};
+}
+const IsoDate = Schema.String.pipe(Schema.filter((value) => Number.isFinite(Date.parse(value)) || "must be an ISO timestamp"));
+const Percent = Schema.Number.pipe(Schema.filter((value) => Number.isFinite(value) && value >= 0 && value <= 100 || "0..100"));
+const QuotaHistoryEventV1Schema = Schema.Struct({
+	schemaVersion: Schema.Literal(1),
+	kind: Schema.Literal("quota_observed", "quota_unavailable", "usage_observed"),
+	eventId: Schema.String,
+	observedAt: IsoDate,
+	recordedAt: IsoDate,
+	provider: Schema.String,
+	accountScope: Schema.NullOr(Schema.String),
+	deviceId: Schema.String,
+	windowId: Schema.String,
+	epochId: Schema.NullOr(Schema.String),
+	semantics: Schema.Literal("fixed", "rolling", "first_use", "unknown"),
+	startAt: Schema.NullOr(IsoDate),
+	resetAt: Schema.NullOr(IsoDate),
+	usedPercent: Schema.NullOr(Percent),
+	remainingPercent: Schema.NullOr(Percent),
+	source: Schema.String,
+	state: Schema.Literal("ok", "partial", "stale", "error", "unauthenticated"),
+	errorCode: Schema.NullOr(Schema.String),
+	usage: Schema.optional(Schema.Struct({
+		inputTokens: Schema.optional(Schema.Number),
+		outputTokens: Schema.optional(Schema.Number),
+		cacheReadTokens: Schema.optional(Schema.Number),
+		cacheWriteTokens: Schema.optional(Schema.Number),
+		model: Schema.optional(Schema.String),
+		estimatedUsd: Schema.optional(Schema.Number)
+	}))
+});
+const decode = Schema.decodeUnknownEither(QuotaHistoryEventV1Schema, { onExcessProperty: "error" });
+/** Strict decode: unknown (possibly secret-bearing) fields are rejected, not silently kept. */
+function decodeHistoryEvent(input) {
+	return decode(input);
+}
+const validPercent = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 100;
+const minuteIso = (ms) => (/* @__PURE__ */ new Date(Math.round(ms / 6e4) * 6e4)).toISOString();
+function makeId(parts) {
+	return sha256Hex(parts.map((part) => part === null ? "\0" : String(part)).join(""));
+}
+/** Pure normalization: one event per measurable window, or one sanitized unavailable event. */
+function historyEventsFromSnapshot(snapshot, options) {
+	const observedMs = Date.parse(snapshot.fetchedAt);
+	if (!Number.isFinite(observedMs)) return [];
+	const observedAt = new Date(observedMs).toISOString();
+	const base = {
+		schemaVersion: 1,
+		observedAt,
+		recordedAt: options.recordedAt,
+		provider: snapshot.provider,
+		accountScope: options.accountScope,
+		deviceId: options.deviceId,
+		source: snapshot.source
+	};
+	const measurable = snapshot.windows.filter((w) => validPercent(w.usedPercent));
+	if (!(snapshot.status === "ok" || snapshot.status === "partial") || measurable.length === 0) {
+		const state = snapshot.status === "unauthenticated" ? "unauthenticated" : "error";
+		const errorCode = snapshot.errorCode ?? snapshot.status.toUpperCase();
+		return [{
+			...base,
+			kind: "quota_unavailable",
+			eventId: makeId([
+				"quota_unavailable",
+				snapshot.provider,
+				options.accountScope,
+				options.deviceId,
+				observedAt,
+				state,
+				errorCode
+			]),
+			windowId: "*",
+			epochId: null,
+			semantics: "unknown",
+			startAt: null,
+			resetAt: null,
+			usedPercent: null,
+			remainingPercent: null,
+			state,
+			errorCode
+		}];
+	}
+	const state = options.stale ? "stale" : snapshot.status === "partial" ? "partial" : "ok";
+	return measurable.map((window) => {
+		const profile = windowProfile(snapshot.provider, window.windowId, window.resetAt);
+		const semantics = options.semanticsForWindow?.(window.windowId) ?? profile.semantics;
+		const resetMs = window.resetAt === null ? NaN : Date.parse(window.resetAt);
+		const hasReset = Number.isFinite(resetMs);
+		const epochId = hasReset ? minuteIso(resetMs) : null;
+		const providedStart = options.startForWindow?.(window.windowId) ?? null;
+		const startAt = providedStart !== null && Number.isFinite(Date.parse(providedStart)) ? new Date(providedStart).toISOString() : hasReset && profile.durationMs !== null ? new Date(resetMs - profile.durationMs).toISOString() : null;
+		const usedPercent = window.usedPercent;
+		const remaining = validPercent(window.remainingPercent) ? window.remainingPercent : Math.max(0, Math.min(100, 100 - usedPercent));
+		return {
+			...base,
+			kind: "quota_observed",
+			eventId: makeId([
+				"quota_observed",
+				snapshot.provider,
+				options.accountScope,
+				options.deviceId,
+				window.windowId,
+				epochId,
+				observedAt,
+				usedPercent,
+				state
+			]),
+			windowId: window.windowId,
+			epochId,
+			semantics,
+			startAt,
+			resetAt: hasReset ? new Date(resetMs).toISOString() : null,
+			usedPercent,
+			remainingPercent: remaining,
+			state,
+			errorCode: snapshot.status === "partial" ? snapshot.errorCode : null
+		};
+	});
+}
+export { sha256Hex as a, QuotaStatusSchema as c, windowProfile as i, QuotaWindowSchema as l, decodeHistoryEvent as n, ProviderIdSchema as o, historyEventsFromSnapshot as r, QuotaSnapshotSchema as s, QuotaHistoryEventV1Schema as t };