@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
189 lines (178 loc) • 8.87 kB
text/typescript
import { dlopen, ptr, read, type Pointer } from "bun:ffi";
import { win32 } from "node:path";
import { readWindowsCurrentSid, type WindowsTokenSidApi } from "../codex/windows-current-sid";
import { resolveTrustedWindowsSystemDirectory } from "./windows-elevation";
import { spawnWorker } from "./worker-embed";
export interface NativeWindowsPrincipal { readonly sid: string; readonly name: string }
export interface WindowsNativePrincipalApi extends WindowsTokenSidApi {
lookupAccountSid(sid: number, name: Uint16Array | null, nameLength: Uint32Array,
domain: Uint16Array | null, domainLength: Uint32Array, use: Uint32Array): number;
lastError(): number;
}
const MAX_ACCOUNT_CODE_UNITS = 32_768;
function lookupError(): Error { return new Error("Windows native account translation failed."); }
function wideString(buffer: Uint16Array, reported: number): string {
if (reported > buffer.length) throw lookupError();
const end = buffer.indexOf(0);
if (end < 0) throw lookupError();
const value = String.fromCharCode(...buffer.subarray(0, end));
if (/[\r\n]/.test(value)) throw lookupError();
return value;
}
function accountName(api: WindowsNativePrincipalApi, sid: number): string {
const nameLength = new Uint32Array(1), domainLength = new Uint32Array(1), use = new Uint32Array(1);
const sized = api.lookupAccountSid(sid, null, nameLength, null, domainLength, use);
const error = sized === 0 ? api.lastError() : 0;
if (sized !== 0 || error !== 122 || nameLength[0]! < 2
|| nameLength[0]! > MAX_ACCOUNT_CODE_UNITS || domainLength[0]! > MAX_ACCOUNT_CODE_UNITS) {
throw lookupError();
}
const name = new Uint16Array(nameLength[0]!);
// An empty domain is valid; its storage still needs a non-null, addressable NUL.
const domain = new Uint16Array(Math.max(1, domainLength[0]!));
domainLength[0] = domain.length;
if (api.lookupAccountSid(sid, name, nameLength, domain, domainLength, use) === 0) {
// No resize/retry downgrade: an unmapped SID or changing requirement refuses.
throw lookupError();
}
const account = wideString(name, nameLength[0]!);
const authority = wideString(domain, domainLength[0]!);
if (!account) throw lookupError();
return authority ? `${authority}\\${account}` : account;
}
/** Reuse the token reader's lifetime; translate its live binary SID before allocating the string. */
export function readWindowsNativePrincipal(api: WindowsNativePrincipalApi): NativeWindowsPrincipal {
let name = "";
const sid = readWindowsCurrentSid({
...api,
convertSidToStringSid(address, output) {
// The reader synchronously invokes this while retaining TOKEN_USER's backing buffer.
name = accountName(api, address);
return api.convertSidToStringSid(address, output);
},
});
return Object.freeze({ sid, name });
}
interface NativeResolution {
platform: NodeJS.Platform;
arch: string;
systemDirectory(): string;
load: typeof dlopen;
}
/** Null means unsupported native execution. DLL/path/API failures propagate, never downgrade. */
export function resolveWindowsNativePrincipal(resolution: NativeResolution = {
platform: process.platform, arch: process.arch,
systemDirectory: resolveTrustedWindowsSystemDirectory, load: dlopen,
}): NativeWindowsPrincipal | null {
if (resolution.platform !== "win32" || resolution.arch !== "x64") return null;
const directory = resolution.systemDirectory();
const advapi = resolution.load(win32.join(directory, "advapi32.dll"), {
OpenProcessToken: { args: ["u64", "u32", "ptr"], returns: "i32" },
GetTokenInformation: { args: ["u64", "u32", "ptr", "u32", "ptr"], returns: "i32" },
ConvertSidToStringSidW: { args: ["ptr", "ptr"], returns: "i32" },
LookupAccountSidW: { args: ["ptr", "ptr", "ptr", "ptr", "ptr", "ptr", "ptr"], returns: "i32" },
});
try {
const kernel = resolution.load(win32.join(directory, "kernel32.dll"), {
GetCurrentProcess: { args: [], returns: "u64" },
CloseHandle: { args: ["u64"], returns: "i32" },
LocalFree: { args: ["ptr"], returns: "ptr" },
GetLastError: { args: [], returns: "u32" },
});
try {
return readWindowsNativePrincipal({
openProcessToken: (access, output) => advapi.symbols.OpenProcessToken(
kernel.symbols.GetCurrentProcess(), access, ptr(output)),
getTokenInformation: (token, kind, buffer, length) => advapi.symbols.GetTokenInformation(
token, kind, ptr(buffer), buffer.byteLength, ptr(length)),
convertSidToStringSid: (address, output) => advapi.symbols.ConvertSidToStringSidW(
address as Pointer, ptr(output)),
lookupAccountSid: (address, name, nameLength, domain, domainLength, use) =>
advapi.symbols.LookupAccountSidW(null, address as Pointer, name ? ptr(name) : null,
ptr(nameLength), domain ? ptr(domain) : null, ptr(domainLength), ptr(use)),
lastError: () => kernel.symbols.GetLastError(),
readCodeUnit: (address, offset) => read.u16(address as Pointer, offset),
localFree: address => { kernel.symbols.LocalFree(address as Pointer); },
closeHandle: token => { kernel.symbols.CloseHandle(token); },
});
} finally { kernel.close(); }
} finally { advapi.close(); }
}
export interface NativePrincipalTiming {
now(): number;
schedule(callback: () => void, milliseconds: number): () => void;
}
const timing: NativePrincipalTiming = {
now: () => performance.now(),
schedule: (callback, milliseconds) => {
const timer = setTimeout(callback, milliseconds);
return () => clearTimeout(timer);
},
};
/** A worker may remain in FFI after a caller expires; its slot belongs to closure, not the caller. */
export function createWindowsNativePrincipalLookup(
createWorker: () => Worker = () => spawnWorker(
new URL("./windows-native-principal-worker.ts", import.meta.url).href, "windows-native-principal-worker"),
): (timeoutMs: number, clock?: NativePrincipalTiming) => Promise<NativeWindowsPrincipal | null> {
let active: { result: Promise<NativeWindowsPrincipal | null> } | null = null;
const start = () => {
const worker = createWorker();
let resolve!: (identity: NativeWindowsPrincipal | null) => void, reject!: (error: Error) => void;
const job = { result: new Promise<NativeWindowsPrincipal | null>((yes, no) => { resolve = yes; reject = no; }) };
void job.result.catch(() => {});
active = job;
let response: NativeWindowsPrincipal | null | undefined;
let received = false;
const fail = () => reject(lookupError());
worker.addEventListener("message", event => {
if (received) { fail(); return; }
received = true;
const message: unknown = event.data;
if (!message || typeof message !== "object") { fail(); return; }
const data = message as Record<string, unknown>;
if (data.kind === "unavailable") response = null;
else if (data.kind === "identity" && typeof data.sid === "string" && typeof data.name === "string") {
response = { sid: data.sid, name: data.name };
} else fail();
});
worker.addEventListener("error", fail);
worker.addEventListener("messageerror", fail);
worker.addEventListener("close", () => {
if (active === job) active = null;
if (received && response !== undefined) resolve(response);
else fail();
}, { once: true });
(worker as Worker & { unref(): void }).unref();
try { worker.postMessage({ kind: "lookup" }); }
catch { fail(); }
return job;
};
return (timeoutMs, clock = timing) => {
const deadline = clock.now() + timeoutMs;
return new Promise((resolve, reject) => {
let settled = false, cancel = () => {};
const finish = (error?: unknown, identity?: NativeWindowsPrincipal | null) => {
if (settled) return;
settled = true; cancel();
if (error) reject(error); else resolve(identity!);
};
const expired = () => finish(new Error("Windows native principal lookup timed out."));
if (timeoutMs <= 0) { expired(); return; }
cancel = clock.schedule(expired, timeoutMs);
if (settled) { cancel(); return; }
try {
const job = active ?? start();
// Timer callbacks can lag synchronous worker construction or promise delivery.
if (clock.now() >= deadline) expired();
void job.result.then(identity => {
if (clock.now() >= deadline) expired(); else finish(undefined, identity);
}, error => finish(error));
} catch (error) { finish(error); }
});
};
}
const nativeLookup = createWindowsNativePrincipalLookup();
export function resolveWindowsNativePrincipalAsync(timeoutMs: number): Promise<NativeWindowsPrincipal | null> {
if (process.platform !== "win32" || process.arch !== "x64") return Promise.resolve(null);
return nativeLookup(timeoutMs);
}