@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/kimi-Dh0pv3WZ.mjs

@@ -0,0 +1,236 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-Bx0fpxuk.mjs";
+import { H as getAgentDir, P as $env } from "./src-BgpusnsB.mjs";
+import { c as OAuthError, h as LoginCancelledError } from "./error-Dd8DIqs-.mjs";
+import "./utils-Cp76gCyk.mjs";
+import { n as isRecord } from "./type-guards-B9VVjRDK.mjs";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import { scheduler } from "node:timers/promises";
+import * as crypto from "node:crypto";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/package.json
+var version = "17.3.5";
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/registry/oauth/kimi.ts
+/**
+* Kimi Code OAuth flow (device authorization grant)
+*/
+var kimi_exports = /* @__PURE__ */ __exportAll({
+	getKimiCommonHeaders: () => getKimiCommonHeaders,
+	loginKimi: () => loginKimi,
+	refreshKimiToken: () => refreshKimiToken
+});
+const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
+const DEFAULT_OAUTH_HOST = "https://auth.kimi.com";
+const DEVICE_ID_FILENAME = "kimi-device-id";
+const DEFAULT_POLL_INTERVAL_MS = 5e3;
+const DEFAULT_DEVICE_FLOW_TTL_MS = 9e5;
+const OAUTH_EXPIRY_SKEW_MS = 3e5;
+function resolveOAuthHost() {
+	return $env.KIMI_CODE_OAUTH_HOST || $env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST;
+}
+function formatDeviceModel(system, release, arch) {
+	return [
+		system,
+		release,
+		arch
+	].filter(Boolean).join(" ").trim();
+}
+function getDeviceModel() {
+	const platform = os.platform();
+	const release = os.release();
+	const arch = os.arch();
+	if (platform === "darwin") return formatDeviceModel("macOS", release, arch);
+	if (platform === "win32") return formatDeviceModel("Windows", release, arch);
+	return formatDeviceModel(platform === "linux" ? "Linux" : platform, release, arch);
+}
+let getDeviceId = () => {
+	const deviceIdPath = path.join(getAgentDir(), DEVICE_ID_FILENAME);
+	try {
+		const existing = fs.readFileSync(deviceIdPath, "utf-8").trim();
+		if (existing) {
+			getDeviceId = () => existing;
+			return existing;
+		}
+	} catch {}
+	const deviceId = crypto.randomUUID().replace(/-/g, "");
+	try {
+		fs.mkdirSync(path.dirname(deviceIdPath), { recursive: true });
+		fs.writeFileSync(deviceIdPath, `${deviceId}\n`, { mode: 384 });
+	} catch {}
+	getDeviceId = () => deviceId;
+	return deviceId;
+};
+function sanitizeHeaderValue(value, fallback = "") {
+	return value.replace(/[^\x20-\x7E]/g, "").trim() || fallback;
+}
+let getKimiCommonHeaders = () => {
+	const headers = Object.freeze({
+		"User-Agent": `KimiCLI/${version}`,
+		"X-Msh-Platform": "kimi_cli",
+		"X-Msh-Version": version,
+		"X-Msh-Device-Name": sanitizeHeaderValue(os.hostname(), "unknown"),
+		"X-Msh-Device-Model": sanitizeHeaderValue(getDeviceModel(), "unknown"),
+		"X-Msh-Os-Version": sanitizeHeaderValue(os.version(), "unknown"),
+		"X-Msh-Device-Id": sanitizeHeaderValue(getDeviceId(), "unknown")
+	});
+	getKimiCommonHeaders = () => headers;
+	return headers;
+};
+async function requestDeviceAuthorization() {
+	const response = await fetch(`${resolveOAuthHost()}/api/oauth/device_authorization`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			...getKimiCommonHeaders()
+		},
+		body: new URLSearchParams({ client_id: CLIENT_ID })
+	});
+	if (!response.ok) {
+		const text = await response.text();
+		throw new OAuthError(`Kimi device authorization failed: ${response.status} ${text}`, {
+			kind: "device-auth",
+			provider: "kimi",
+			status: response.status
+		});
+	}
+	const payload = await response.json();
+	const userCode = payload.user_code;
+	const deviceCode = payload.device_code;
+	const verificationUri = payload.verification_uri;
+	const verificationUriComplete = payload.verification_uri_complete;
+	if (!userCode || !deviceCode || !verificationUri) throw new OAuthError("Kimi device authorization response missing required fields", {
+		kind: "validation",
+		provider: "kimi"
+	});
+	const expiresInMs = typeof payload.expires_in === "number" ? payload.expires_in * 1e3 : DEFAULT_DEVICE_FLOW_TTL_MS;
+	const intervalMs = typeof payload.interval === "number" && payload.interval > 0 ? payload.interval * 1e3 : DEFAULT_POLL_INTERVAL_MS;
+	return {
+		userCode,
+		deviceCode,
+		verificationUri,
+		verificationUriComplete: verificationUriComplete || verificationUri,
+		expiresInMs,
+		intervalMs
+	};
+}
+function parseTokenPayload(payload, refreshTokenFallback) {
+	if (!payload.access_token || typeof payload.expires_in !== "number") throw new OAuthError("Kimi token response missing required fields", {
+		kind: "validation",
+		provider: "kimi"
+	});
+	const refresh = payload.refresh_token ?? refreshTokenFallback;
+	if (!refresh) throw new OAuthError("Kimi token response missing refresh token", {
+		kind: "validation",
+		provider: "kimi"
+	});
+	let accountId;
+	const tokenParts = payload.access_token.split(".");
+	const jwtPayloadPart = tokenParts.length === 3 ? tokenParts[1] : void 0;
+	if (jwtPayloadPart) try {
+		const jwtPayload = JSON.parse(new TextDecoder("utf-8").decode(Uint8Array.fromBase64(jwtPayloadPart, { alphabet: "base64url" })));
+		if (isRecord(jwtPayload)) {
+			const userId = typeof jwtPayload.user_id === "string" ? jwtPayload.user_id.trim() : "";
+			const subject = typeof jwtPayload.sub === "string" ? jwtPayload.sub.trim() : "";
+			accountId = userId || subject || void 0;
+		}
+	} catch {}
+	return {
+		access: payload.access_token,
+		refresh,
+		expires: Date.now() + payload.expires_in * 1e3 - OAUTH_EXPIRY_SKEW_MS,
+		accountId
+	};
+}
+async function pollForToken(deviceCode, intervalMs, expiresInMs, signal) {
+	const deadline = Date.now() + expiresInMs;
+	let waitMs = Math.max(1e3, intervalMs);
+	while (Date.now() < deadline) {
+		if (signal?.aborted) throw new LoginCancelledError();
+		const response = await fetch(`${resolveOAuthHost()}/api/oauth/token`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded",
+				...getKimiCommonHeaders()
+			},
+			body: new URLSearchParams({
+				client_id: CLIENT_ID,
+				device_code: deviceCode,
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+			})
+		});
+		const payload = await response.json();
+		if (response.ok && payload.access_token) return parseTokenPayload(payload);
+		const error = payload.error;
+		if (error === "authorization_pending") {
+			await scheduler.wait(waitMs, { signal });
+			continue;
+		}
+		if (error === "slow_down") {
+			waitMs += 5e3;
+			const retryAfter = typeof payload.interval === "number" ? payload.interval * 1e3 : void 0;
+			if (retryAfter && retryAfter > waitMs) waitMs = retryAfter;
+			await scheduler.wait(waitMs, { signal });
+			continue;
+		}
+		if (error === "expired_token") throw new OAuthError("Kimi device authorization expired", {
+			kind: "validation",
+			provider: "kimi"
+		});
+		if (error === "access_denied") throw new OAuthError("Kimi device authorization denied", {
+			kind: "validation",
+			provider: "kimi"
+		});
+		const description = payload.error_description ? `: ${payload.error_description}` : "";
+		throw new OAuthError(`Kimi device flow failed: ${error ?? response.status}${description}`, {
+			kind: "polling",
+			provider: "kimi"
+		});
+	}
+	throw new OAuthError("Kimi device flow timed out", {
+		kind: "timeout",
+		provider: "kimi"
+	});
+}
+/**
+* Login with Kimi Code OAuth (device code flow).
+*/
+async function loginKimi(options) {
+	const device = await requestDeviceAuthorization();
+	options.onAuth?.({
+		url: device.verificationUriComplete,
+		instructions: `Enter code: ${device.userCode}`
+	});
+	return pollForToken(device.deviceCode, device.intervalMs, device.expiresInMs, options.signal);
+}
+/**
+* Refresh Kimi OAuth token.
+*/
+async function refreshKimiToken(refreshToken) {
+	const response = await fetch(`${resolveOAuthHost()}/api/oauth/token`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/x-www-form-urlencoded",
+			...getKimiCommonHeaders()
+		},
+		body: new URLSearchParams({
+			grant_type: "refresh_token",
+			refresh_token: refreshToken,
+			client_id: CLIENT_ID
+		})
+	});
+	if (!response.ok) {
+		const payload = await response.json().catch(() => void 0);
+		const description = payload?.error_description ? `: ${payload.error_description}` : "";
+		throw new OAuthError(`Kimi token refresh failed: ${response.status}${description}`, {
+			kind: "token-refresh",
+			provider: "kimi",
+			status: response.status
+		});
+	}
+	return parseTokenPayload(await response.json(), refreshToken);
+}
+//#endregion
+export { kimi_exports as n, getKimiCommonHeaders as t };