@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
133 lines (117 loc) • 5.42 kB
text/typescript
/**
* Decode bounded text emitted by Windows system tools.
*
* [Decision Log]
* - Purpose: preserve non-ASCII paths when a Windows tool writes the active
* legacy code page instead of UTF-8.
* - Existing constraint: generated service assets may be UTF-16, while
* redirected `schtasks` output follows the Windows locale on affected hosts.
* - Alternatives considered: replacement-character heuristics and a new
* iconv dependency. The former can reinterpret valid text; the latter widens
* the install/security surface for two small, already-supported codecs.
* - Choice: recognize UTF-16 first, accept only strict UTF-8 next, then use the
* locale-appropriate WHATWG decoder (CP949 through `euc-kr`, or Windows-1252
* only for locales that actually use that family). Unknown/unsupported
* locales fail back to the old replacement-preserving UTF-8 result instead
* of guessing another code page or throwing in diagnostics.
* - Impact: decoding stays dependency-free and bounded, but this deliberately
* does not guess arbitrary OEM code pages that the runtime cannot identify.
*/
function trimWindowsText(value: string): string {
return value.replace(/^\uFEFF/, "").trim();
}
function currentWindowsLocale(): string {
try {
return Intl.DateTimeFormat().resolvedOptions().locale;
} catch {
return "en-US";
}
}
function decodeStrict(buffer: Uint8Array, encoding: string): string | null {
try {
return trimWindowsText(new TextDecoder(encoding, { fatal: true }).decode(buffer));
} catch {
return null;
}
}
function decodeUtf16Be(buffer: Uint8Array): string {
const payloadLength = buffer.length - 2;
const swapped = Buffer.alloc(payloadLength - (payloadLength % 2));
for (let i = 2; i + 1 < buffer.length; i += 2) {
swapped[i - 2] = buffer[i + 1]!;
swapped[i - 1] = buffer[i]!;
}
return trimWindowsText(swapped.toString("utf16le"));
}
/**
* CP949 is exposed by the Encoding Standard under the `euc-kr` label. Keep the
* Western fallback deliberately narrow: treating CP932, CP1250, or CP1251
* bytes as Windows-1252 can fabricate a different valid-looking filesystem
* path, which is worse than the previous replacement-character refusal.
*
* The CJK double-byte pages are named for the same reason `euc-kr` is: they are
* the ANSI code page on their own hosts, they are unambiguous for that language
* tag, and `decodeStrict` rejects a mismatch instead of inventing a path. A
* zh-CN host's schtasks stderr is CP936 (`gbk`), which the UTF-8 attempt above
* fails on and which previously fell through to a lossy UTF-8 decode — the
* mojibake made every localized message unmatchable (#2914).
*
* zh-Hant is a separate page (`big5`), not a variant of the same one, so the
* region subtag decides: `zh-TW`/`zh-HK`/`zh-MO` are Big5, bare `zh` and
* `zh-CN`/`zh-SG` are GBK. Guessing wrong here is exactly the fabricated-path
* risk the Western note describes, so an unrecognized `zh-*` region keeps the
* mainland default rather than trying both.
*/
function legacyEncodingForLocale(locale: string): LegacyWindowsEncoding | null {
const parts = locale.trim().split(/[-_]/);
const language = parts[0]?.toLowerCase();
if (language === "ko") return "euc-kr";
if (language === "ja") return "shift_jis";
if (language === "zh") return traditionalChineseRegion(parts) ? "big5" : "gbk";
if (language && WINDOWS_1252_LANGUAGES.has(language)) return "windows-1252";
return null;
}
type LegacyWindowsEncoding = "euc-kr" | "shift_jis" | "gbk" | "big5" | "windows-1252";
/** `zh-Hant`, or a region that ships Big5 as its ANSI code page. */
function traditionalChineseRegion(parts: readonly string[]): boolean {
return parts.slice(1).some(part => {
const tag = part.toLowerCase();
return tag === "hant" || tag === "tw" || tag === "hk" || tag === "mo";
});
}
const WINDOWS_1252_LANGUAGES = new Set([
"af", "br", "ca", "co", "cy", "da", "de", "en", "es", "eu", "fi", "fo", "fr",
"ga", "gd", "gl", "id", "is", "it", "lb", "ms", "nl", "no", "oc", "pt", "sq",
"sv", "sw",
]);
export interface WindowsTextDecodeOptions {
/** Test seam and explicit locale override; production uses the active Intl locale. */
readonly locale?: string;
}
export function decodeWindowsTextBytes(
buffer: Uint8Array,
options: WindowsTextDecodeOptions = {},
): string {
if (buffer.length === 0) return "";
const bomUtf16Le = buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe;
const bomUtf16Be = buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff;
const looksUtf16Le = buffer.length >= 4
&& buffer[1] === 0x00
&& buffer[3] === 0x00
&& buffer[0] !== 0x00;
if (bomUtf16Le || looksUtf16Le) {
return trimWindowsText(Buffer.from(buffer).toString("utf16le"));
}
if (bomUtf16Be) return decodeUtf16Be(buffer);
const utf8 = decodeStrict(buffer, "utf-8");
if (utf8 !== null) return utf8;
const locale = options.locale ?? currentWindowsLocale();
const legacyEncoding = legacyEncodingForLocale(locale);
if (legacyEncoding !== null) {
const legacy = decodeStrict(buffer, legacyEncoding);
if (legacy !== null) return legacy;
}
// Preserve the previous fail-soft behavior when the runtime lacks a codec or
// the bytes are malformed even for the selected Windows code page.
return trimWindowsText(new TextDecoder("utf-8").decode(buffer));
}