@izykitten/ce 0.0.1 → 0.0.3-dev.0

package/src/libc.ts

@@ -1,104 +0,0 @@
-// The two libc calls Bun has no API for: flock(2) and execve(2).
-//
-// - flock: the Python `ce` serializes credential-helper state with
-//   `fcntl.flock(<state>.lock, LOCK_EX)`. Taking the very same kernel lock (not
-//   a lockfile scheme) keeps this port mutually exclusive with a Python `ce`
-//   sharing the same ~/.docker, and the kernel drops it when a holder dies.
-// - execve: the Python `ce` ends with `os.execvp`, replacing itself with the
-//   engine so it keeps the PID, signals, TTY and exit status. A real execve does
-//   the same here, with no signal-forwarding or exit-code-relaying layer.
-//
-// libc is opened lazily so commands that never lock or exec (help, argument
-// errors) do not depend on bun:ffi.
-
-import { dlopen, FFIType, ptr, read } from "bun:ffi";
-
-const LIBC_CANDIDATES: Record<string, string[]> = {
-  // musl resolves these reserved names to its built-in libc as well.
-  linux: ["libc.so.6", "libc.so", "libc.musl-x86_64.so.1", "libc.musl-aarch64.so.1"],
-  darwin: ["libc.dylib", "/usr/lib/libSystem.B.dylib"],
-};
-
-const symbols = {
-  flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 },
-  execve: { args: [FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
-  strerror: { args: [FFIType.i32], returns: FFIType.cstring },
-} as const;
-
-type Libc = ReturnType<typeof dlopen<typeof symbols>>["symbols"] & {
-  errnoLocation: () => number | null;
-};
-
-let cached: Libc | undefined;
-
-function libc(): Libc {
-  if (cached) return cached;
-  const errnoSymbol = process.platform === "darwin" ? "__error" : "__errno_location";
-  const errors: string[] = [];
-  for (const name of LIBC_CANDIDATES[process.platform] ?? ["libc.so.6"]) {
-    try {
-      const lib = dlopen(name, {
-        ...symbols,
-        [errnoSymbol]: { args: [], returns: FFIType.ptr },
-      });
-      const s = lib.symbols as unknown as Record<string, (...a: unknown[]) => unknown>;
-      cached = {
-        ...(lib.symbols as unknown as Libc),
-        errnoLocation: s[errnoSymbol] as () => number | null,
-      };
-      return cached;
-    } catch (exc) {
-      errors.push(`${name}: ${(exc as Error).message}`);
-    }
-  }
-  throw new Error(`ce: cannot load libc via bun:ffi (${errors.join("; ")})`);
-}
-
-/** The calling thread's errno, read right after a failed libc call. */
-export function errno(): number {
-  const location = libc().errnoLocation();
-  return location ? read.i32(location, 0) : 0;
-}
-
-/** strerror(3) text, as Python puts in "[Errno N] <text>". */
-export function strerror(code: number): string {
-  try {
-    return String(libc().strerror(code));
-  } catch {
-    return `Unknown error ${code}`;
-  }
-}
-
-export const LOCK_EX = 2;
-export const EINTR = 4;
-
-/** Blocking flock(2). Returns 0 or the failing errno (EINTR is retried, as Python's PEP 475 does). */
-export function flock(fd: number, operation: number): number {
-  for (;;) {
-    if (libc().flock(fd, operation) === 0) return 0;
-    const code = errno();
-    if (code !== EINTR) return code;
-  }
-}
-
-function cString(value: string): Buffer {
-  return Buffer.from(`${value}\0`, "utf8");
-}
-
-/**
- * execve(2). Only returns on failure, with the errno. The buffers stay
- * referenced until the call returns, so the pointers handed to libc are valid.
- */
-export function execve(path: string, argv: string[], env: Record<string, string | undefined>): number {
-  const pathBuf = cString(path);
-  const argBufs = argv.map(cString);
-  const envBufs = Object.entries(env)
-    .filter((entry): entry is [string, string] => entry[1] !== undefined)
-    .map(([key, value]) => cString(`${key}=${value}`));
-  const argPtrs = new BigUint64Array(argBufs.length + 1);
-  argBufs.forEach((buf, i) => (argPtrs[i] = BigInt(ptr(buf))));
-  const envPtrs = new BigUint64Array(envBufs.length + 1);
-  envBufs.forEach((buf, i) => (envPtrs[i] = BigInt(ptr(buf))));
-  libc().execve(pathBuf, argPtrs, envPtrs);
-  return errno();
-}