self-bench 0.3.0 → 0.3.3

package/src/sandbox.ts

@@ -0,0 +1,51 @@
+import type { SelfBenchConfig } from "./config.js";
+import { DockerSandboxExecutor } from "./docker-executor.js";
+import { ModalSandboxExecutor } from "./modal-executor.js";
+
+export interface SandboxFile {
+  readonly path: string;
+  readonly contents: Uint8Array | string;
+}
+
+export interface SandboxRequest {
+  readonly runId: string;
+  readonly stage: string;
+  readonly command: readonly string[];
+  readonly files?: readonly SandboxFile[];
+  readonly outputPaths?: readonly string[];
+  readonly environment?: Readonly<Record<string, string>>;
+  readonly secrets?: Readonly<Record<string, string>>;
+  readonly timeoutMs: number;
+  readonly inactivityTimeoutMs?: number;
+  readonly cpu?: number;
+  readonly memoryMiB?: number;
+}
+
+export interface SandboxProgress {
+  readonly stream: "stdout" | "stderr";
+  readonly bytes: number;
+}
+
+export interface SandboxRunOptions {
+  readonly signal?: AbortSignal;
+  readonly onProgress?: (progress: SandboxProgress) => void;
+}
+
+export interface SandboxResult {
+  readonly sandboxId: string;
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly outputs: Readonly<Record<string, Uint8Array>>;
+}
+
+export interface SandboxExecutor {
+  run(request: SandboxRequest, options?: SandboxRunOptions): Promise<SandboxResult>;
+  close(): void;
+}
+
+export function createSandboxExecutor(config: SelfBenchConfig["execution"]): SandboxExecutor {
+  return config.kind === "modal"
+    ? new ModalSandboxExecutor(config)
+    : new DockerSandboxExecutor(config);
+}

package/src/subscription-auth.ts

@@ -0,0 +1,80 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { runCommand } from "./process.js";
+
+export interface PiModelAuth {
+  readonly provider: "openai" | "openai-codex";
+  readonly apiKey?: string;
+  readonly authJson?: string;
+}
+
+export interface CodexModelAuth {
+  readonly apiKey?: string;
+  readonly authJson?: string;
+}
+
+export function openAiApiKey(): string | undefined {
+  const key = process.env.OPENAI_API_KEY?.trim();
+  return key || undefined;
+}
+
+export async function loadPiModelAuth(): Promise<PiModelAuth> {
+  const apiKey = openAiApiKey();
+  return apiKey
+    ? { provider: "openai", apiKey }
+    : { provider: "openai-codex", authJson: await loadPiSubscriptionAuth() };
+}
+
+export async function loadCodexModelAuth(): Promise<CodexModelAuth> {
+  const apiKey = openAiApiKey();
+  return apiKey ? { apiKey } : { authJson: await loadCodexSubscriptionAuth() };
+}
+
+export async function loadPiSubscriptionAuth(): Promise<string> {
+  const raw =
+    process.env.SELFBENCH_PI_AUTH_JSON ??
+    (await readFile(join(homedir(), ".pi/agent/auth.json"), "utf8"));
+  const parsed = JSON.parse(raw) as unknown;
+  const credential = isRecord(parsed) ? parsed["openai-codex"] : undefined;
+  if (
+    !isRecord(credential) ||
+    credential.type !== "oauth" ||
+    typeof credential.access !== "string" ||
+    typeof credential.refresh !== "string"
+  ) {
+    throw new Error("Pi auth does not contain an openai-codex subscription credential");
+  }
+  return JSON.stringify({ "openai-codex": credential });
+}
+
+export function assertCodexSubscriptionAuth(value: unknown, source = "Codex auth"): void {
+  if (!isRecord(value) || value.auth_mode !== "chatgpt" || !isRecord(value.tokens)) {
+    throw new Error(`${source} does not contain a ChatGPT subscription token set`);
+  }
+}
+
+export async function loadCodexSubscriptionAuth(): Promise<string> {
+  const path = process.env.CODEX_AUTH_JSON_PATH ?? join(homedir(), ".codex/auth.json");
+  const raw = process.env.SELFBENCH_CODEX_AUTH_JSON ?? (await readFile(path, "utf8"));
+  const parsed = JSON.parse(raw) as unknown;
+  assertCodexSubscriptionAuth(parsed, path);
+  const auth = parsed as Record<string, unknown>;
+  return JSON.stringify({
+    auth_mode: "chatgpt",
+    tokens: auth.tokens,
+    ...(typeof auth.last_refresh === "string" ? { last_refresh: auth.last_refresh } : {}),
+  });
+}
+
+export async function githubToken(): Promise<string | undefined> {
+  if (process.env.GH_TOKEN) {
+    return process.env.GH_TOKEN;
+  }
+  const result = await runCommand("gh", ["auth", "token"], { allowFailure: true });
+  return result.exitCode === 0 && result.stdout.trim() ? result.stdout.trim() : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}