@workos/quickstudy 0.0.1

package/src/isolation/images.ts

@@ -0,0 +1,138 @@
+/**
+ * Image resolution and building.
+ *
+ * The harness core owns exactly one image: `quickstudy/agent-runtime`
+ * (debian-slim + git + the pinned agent CLIs — see images/agent-runtime/).
+ * A runtime may declare per-framework images that layer toolchains on top;
+ * anything it does not declare resolves to the base image.
+ */
+
+import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { IMAGE_CONTEXT_FILES } from "./image-contexts.generated.ts";
+
+/** The base image tag the harness core owns and builds. */
+export const AGENT_RUNTIME_IMAGE = "quickstudy/agent-runtime";
+
+/** The egress-proxy sidecar image — also harness-owned. */
+export const EGRESS_PROXY_IMAGE = "quickstudy/egress-proxy";
+
+/** The MCP token-injecting proxy sidecar image — also harness-owned. */
+export const MCP_PROXY_IMAGE = "quickstudy/mcp-proxy";
+
+/**
+ * Locate the directory holding the harness image build contexts (`images/`
+ * and `src/isolation/`).
+ *
+ * Default: the embedded copies, materialized into a temp directory —
+ * `docker build` needs a real directory to send as context, and the harness
+ * carries one, so the same contexts build from source and from the compiled
+ * binary with no checkout anywhere. The ONLY override is an explicit
+ * `--images-dir` (when iterating on the Dockerfiles themselves, point it at
+ * a checkout — or regenerate: bun scripts/generate-image-contexts.ts).
+ */
+export function resolveImagesRoot(override?: string): string {
+  if (override) return resolve(override);
+  return materializeEmbeddedContexts();
+}
+
+/**
+ * Write the binary-embedded build contexts into a temp directory mirroring
+ * the repo layout, so `imagePaths()` resolves against it unchanged. One
+ * directory per process: the three image builds of `images build` share it.
+ */
+let embeddedRoot: string | undefined;
+export function materializeEmbeddedContexts(): string {
+  if (embeddedRoot !== undefined) return embeddedRoot;
+  const root = mkdtempSync(join(tmpdir(), "quickstudy-image-contexts-"));
+  for (const [rel, contents] of Object.entries(IMAGE_CONTEXT_FILES)) {
+    const abs = join(root, rel);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, contents);
+  }
+  embeddedRoot = root;
+  return root;
+}
+
+/** The build contexts, resolved against a given harness root. */
+function imagePaths(root: string) {
+  return {
+    /** Base-image Dockerfile directory (context = the directory). */
+    agentRuntimeBuildDir: join(root, "images", "agent-runtime"),
+    /**
+     * The egress-proxy Dockerfile and its build CONTEXT (just the proxy
+     * sources — the image copies two files, so shipping the whole repo to the
+     * daemon on every build would be pure waste).
+     */
+    egressProxyDockerfile: join(root, "images", "egress-proxy", "Dockerfile"),
+    egressProxyContext: join(root, "src", "isolation", "proxy"),
+    /** The mcp-proxy Dockerfile and its build context (its single source file). */
+    mcpProxyDockerfile: join(root, "images", "mcp-proxy", "Dockerfile"),
+    mcpProxyContext: join(root, "src", "isolation", "mcp-proxy"),
+  };
+}
+
+/** A build-context-missing error that points at the fix. */
+function missingContext(what: string, path: string): Error {
+  return new Error(
+    `${what} not found at ${path}.\n` +
+      "Point --images-dir at a quickstudy checkout, or omit it — " +
+      "without the flag the binary builds from its own embedded contexts.",
+  );
+}
+
+/** Options common to the base-image builds. */
+export interface BuildImageOptions {
+  /** Pass `docker build --pull` to refresh base layers. */
+  pull?: boolean;
+  /** Override where the build contexts are read from (see {@link resolveImagesRoot}). */
+  imagesRoot?: string;
+}
+
+/**
+ * Build the agent-runtime base image (`quickstudy images build`). Streams
+ * docker's own progress output straight through — this is an interactive
+ * developer command, not an attempt-time operation.
+ */
+export async function buildAgentRuntimeImage(opts: BuildImageOptions = {}): Promise<number> {
+  const { agentRuntimeBuildDir } = imagePaths(resolveImagesRoot(opts.imagesRoot));
+  if (!existsSync(join(agentRuntimeBuildDir, "Dockerfile"))) {
+    throw missingContext("agent-runtime Dockerfile", join(agentRuntimeBuildDir, "Dockerfile"));
+  }
+  const args = ["build", "-t", AGENT_RUNTIME_IMAGE];
+  if (opts.pull) args.push("--pull");
+  args.push(agentRuntimeBuildDir);
+  const proc = Bun.spawn(["docker", ...args], { stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+  return proc.exited;
+}
+
+/**
+ * Build the egress-proxy sidecar image (also part of `quickstudy images
+ * build`). The build context is src/isolation/proxy — the Dockerfile lives
+ * in images/egress-proxy/ next to its sibling, passed via -f.
+ */
+export async function buildEgressProxyImage(opts: BuildImageOptions = {}): Promise<number> {
+  const { egressProxyDockerfile, egressProxyContext } = imagePaths(resolveImagesRoot(opts.imagesRoot));
+  if (!existsSync(egressProxyDockerfile)) {
+    throw missingContext("egress-proxy Dockerfile", egressProxyDockerfile);
+  }
+  const args = ["build", "-t", EGRESS_PROXY_IMAGE, "-f", egressProxyDockerfile];
+  if (opts.pull) args.push("--pull");
+  args.push(egressProxyContext);
+  const proc = Bun.spawn(["docker", ...args], { stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+  return proc.exited;
+}
+
+/** Build the mcp-proxy sidecar image (also part of `quickstudy images build`). */
+export async function buildMcpProxyImage(opts: BuildImageOptions = {}): Promise<number> {
+  const { mcpProxyDockerfile, mcpProxyContext } = imagePaths(resolveImagesRoot(opts.imagesRoot));
+  if (!existsSync(mcpProxyDockerfile)) {
+    throw missingContext("mcp-proxy Dockerfile", mcpProxyDockerfile);
+  }
+  const args = ["build", "-t", MCP_PROXY_IMAGE, "-f", mcpProxyDockerfile];
+  if (opts.pull) args.push("--pull");
+  args.push(mcpProxyContext);
+  const proc = Bun.spawn(["docker", ...args], { stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+  return proc.exited;
+}

package/src/isolation/mcp-proxy/server.ts

@@ -0,0 +1,260 @@
+/**
+ * The MCP token-injecting proxy: attempt containers speak plain,
+ * credential-free HTTP to `http://<sidecar>:<port>/<serverName>`, and this
+ * proxy forwards each request to the real streamable-HTTP MCP server with
+ * `Authorization: Bearer <access token>` attached.
+ *
+ * Why it exists: some MCP servers only accept OAuth bearer tokens, which
+ * expire in minutes and are minted from a refresh token that ROTATES on
+ * every use. Neither belongs anywhere near an agent: a token in vendor
+ * config would land in workspace diffs, and concurrent per-attempt
+ * refreshes would invalidate each other. So the proxy owns the whole token
+ * lifecycle — one serialized refresher per upstream, access tokens cached
+ * until near expiry, one forced refresh + retry on an upstream 401.
+ *
+ * Rotation persistence: every rotated refresh token is written to
+ * `<tokenStateDir>/<name>.refresh-token` (0600). The harness reads that
+ * file back (docker exec) at teardown and persists it for the next run —
+ * losing it costs the operator a re-login, nothing worse.
+ *
+ * Like the egress proxy, this file is self-contained (the sidecar image
+ * copies it alone) and doubles as the container entrypoint. Events go to
+ * `onEvent` in-process and stdout JSON lines in the sidecar; token VALUES
+ * never appear in either.
+ */
+
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface McpUpstream {
+  /** The real MCP server URL requests are forwarded to. */
+  url: string;
+  /** OAuth token endpoint for the refresh grant. */
+  tokenEndpoint: string;
+  /** Public client id (token_endpoint_auth "none"); rides in the form body. */
+  clientId: string;
+  /** RFC 8707 resource indicator — REQUIRED by servers that audience-bind tokens. */
+  resource?: string;
+}
+
+/** One proxy decision or token event. The line shape is stable. */
+export interface McpProxyEvent {
+  type: "mcp-proxy" | "mcp-token" | "listening";
+  ts: string;
+  server?: string;
+  /** mcp-proxy: upstream response status (or 0 when unreachable). */
+  status?: number;
+  method?: string;
+  /** mcp-token: whether the refresh response rotated the refresh token. */
+  rotated?: boolean;
+  error?: string;
+  port?: number;
+}
+
+export interface McpProxyOptions {
+  upstreams: Record<string, McpUpstream>;
+  /** Initial refresh tokens by server name (the only secrets handed in). */
+  refreshTokens: Record<string, string>;
+  /** 0 (default) picks a random free port. Sidecar runs pass a fixed one. */
+  port?: number;
+  /** Bind address. Default 0.0.0.0 (must accept from the attempt network). */
+  hostname?: string;
+  /** Where rotated refresh tokens are persisted, one file per server. */
+  tokenStateDir?: string;
+  onEvent?: (event: McpProxyEvent) => void;
+}
+
+export interface McpProxyHandle {
+  port: number;
+  close(): Promise<void>;
+}
+
+/** Access tokens are refreshed this many ms before their stated expiry. */
+const EXPIRY_SLACK_MS = 30_000;
+/** Assumed lifetime when the token response omits expires_in. */
+const DEFAULT_EXPIRES_IN_S = 300;
+
+/**
+ * Canonical server-name sanitizer, shared BY CONVENTION with
+ * src/isolation/docker.ts (env-var suffixes) — this file cannot import it.
+ */
+export function sanitizeServerName(name: string): string {
+  return name.replace(/[^A-Za-z0-9]/g, "_").toUpperCase();
+}
+
+/** Request headers forwarded upstream; everything else (esp. host) is dropped. */
+const FORWARD_REQUEST_HEADERS = ["content-type", "accept", "mcp-session-id", "mcp-protocol-version", "last-event-id"];
+/** Response headers forwarded back to the agent. */
+const FORWARD_RESPONSE_HEADERS = ["content-type", "mcp-session-id", "mcp-protocol-version"];
+
+interface TokenState {
+  refreshToken: string;
+  accessToken?: string;
+  expiresAtMs?: number;
+  /** Single-flight guard: concurrent requests share one refresh. */
+  inflight?: Promise<void>;
+}
+
+class RefreshError extends Error {
+  readonly oauthCode: string;
+
+  constructor(oauthCode: string) {
+    super(`token refresh failed: ${oauthCode}`);
+    this.oauthCode = oauthCode;
+  }
+}
+
+export function startMcpProxy(options: McpProxyOptions): McpProxyHandle {
+  const emit = (event: Omit<McpProxyEvent, "ts">): void => {
+    options.onEvent?.({ ...event, ts: new Date().toISOString() });
+  };
+  const states = new Map<string, TokenState>();
+  for (const name of Object.keys(options.upstreams)) {
+    const refreshToken = options.refreshTokens[name];
+    if (refreshToken === undefined || refreshToken === "") {
+      throw new Error(`mcp-proxy: no refresh token provided for upstream "${name}"`);
+    }
+    states.set(name, { refreshToken });
+  }
+
+  const persistRefreshToken = (name: string, token: string): void => {
+    if (!options.tokenStateDir) return;
+    const path = join(options.tokenStateDir, `${sanitizeServerName(name)}.refresh-token`);
+    writeFileSync(path, `${token}\n`, { encoding: "utf8", mode: 0o600 });
+    chmodSync(path, 0o600);
+  };
+  if (options.tokenStateDir) {
+    mkdirSync(options.tokenStateDir, { recursive: true, mode: 0o700 });
+    // Written at startup too, so teardown read-back never races the first
+    // rotation and always finds a file per server.
+    for (const [name, state] of states) persistRefreshToken(name, state.refreshToken);
+  }
+
+  async function refresh(name: string, upstream: McpUpstream, state: TokenState): Promise<void> {
+    const response = await fetch(upstream.tokenEndpoint, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: state.refreshToken,
+        client_id: upstream.clientId,
+        ...(upstream.resource !== undefined ? { resource: upstream.resource } : {}),
+      }).toString(),
+    });
+    const body = (await response.json().catch(() => ({}))) as Record<string, unknown>;
+    if (!response.ok || typeof body["access_token"] !== "string") {
+      const code = typeof body["error"] === "string" ? body["error"] : `http_${response.status}`;
+      throw new RefreshError(code);
+    }
+    state.accessToken = body["access_token"];
+    const expiresIn = typeof body["expires_in"] === "number" ? body["expires_in"] : DEFAULT_EXPIRES_IN_S;
+    state.expiresAtMs = Date.now() + expiresIn * 1000;
+    const rotated = typeof body["refresh_token"] === "string" && body["refresh_token"] !== state.refreshToken;
+    if (rotated) {
+      state.refreshToken = body["refresh_token"] as string;
+      persistRefreshToken(name, state.refreshToken);
+    }
+    emit({ type: "mcp-token", server: name, rotated });
+  }
+
+  async function ensureToken(name: string, upstream: McpUpstream, force = false): Promise<string> {
+    const state = states.get(name) as TokenState;
+    const fresh = state.accessToken !== undefined && state.expiresAtMs !== undefined && Date.now() < state.expiresAtMs - EXPIRY_SLACK_MS;
+    if (!force && fresh) return state.accessToken as string;
+    if (!state.inflight) {
+      state.inflight = refresh(name, upstream, state).finally(() => {
+        state.inflight = undefined;
+      });
+    }
+    await state.inflight;
+    return state.accessToken as string;
+  }
+
+  function forward(upstream: McpUpstream, request: Request, body: ArrayBuffer | undefined, accessToken: string): Promise<Response> {
+    const headers = new Headers({ authorization: `Bearer ${accessToken}` });
+    for (const header of FORWARD_REQUEST_HEADERS) {
+      const value = request.headers.get(header);
+      if (value !== null) headers.set(header, value);
+    }
+    return fetch(upstream.url, { method: request.method, headers, ...(body !== undefined ? { body } : {}) });
+  }
+
+  const server = Bun.serve({
+    hostname: options.hostname ?? "0.0.0.0",
+    port: options.port ?? 0,
+    idleTimeout: 0, // SSE streams are long-lived by design
+    async fetch(request) {
+      const name = new URL(request.url).pathname.replace(/^\//, "");
+      const upstream = options.upstreams[name];
+      if (!upstream) return Response.json({ error: "unknown_server", server: name }, { status: 404 });
+
+      try {
+        // JSON-RPC requests are small — buffer ONCE (a request body cannot be
+        // re-read, and the 401 path forwards it twice). RESPONSES stream
+        // (SSE sessions are long-lived and unbounded).
+        const body = request.method === "GET" || request.method === "HEAD" ? undefined : await request.arrayBuffer();
+        let token = await ensureToken(name, upstream);
+        let response = await forward(upstream, request, body, token);
+        if (response.status === 401) {
+          // The cached token may have been revoked upstream — refresh once
+          // and retry once; a second 401 is the upstream's real answer.
+          token = await ensureToken(name, upstream, true);
+          response = await forward(upstream, request, body, token);
+        }
+        emit({ type: "mcp-proxy", server: name, method: request.method, status: response.status });
+        const headers = new Headers();
+        for (const header of FORWARD_RESPONSE_HEADERS) {
+          const value = response.headers.get(header);
+          if (value !== null) headers.set(header, value);
+        }
+        return new Response(response.body, { status: response.status, headers });
+      } catch (error) {
+        const detail = error instanceof RefreshError ? error.oauthCode : "upstream_unreachable";
+        emit({ type: "mcp-proxy", server: name, method: request.method, status: 0, error: detail });
+        return Response.json({ error: "mcp_proxy_error", detail }, { status: 502 });
+      }
+    },
+  });
+
+  emit({ type: "listening", port: server.port ?? options.port ?? 0 });
+  return {
+    port: server.port ?? options.port ?? 0,
+    close: async () => {
+      await server.stop(true);
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Sidecar entrypoint (images/mcp-proxy/Dockerfile). Config via env:
+//   QUICKSTUDY_MCP_UPSTREAMS               JSON {name: McpUpstream} (required)
+//   QUICKSTUDY_MCP_REFRESH_TOKEN_<NAME>    initial refresh token per server,
+//                                          NAME per sanitizeServerName
+//   QUICKSTUDY_MCP_PORT                    listen port (default 8914)
+//   QUICKSTUDY_MCP_TOKEN_STATE_DIR         rotation files (default /run/quickstudy-mcp)
+// ---------------------------------------------------------------------------
+
+if (import.meta.main) {
+  const rawUpstreams = process.env["QUICKSTUDY_MCP_UPSTREAMS"];
+  if (!rawUpstreams) {
+    console.error("mcp-proxy: QUICKSTUDY_MCP_UPSTREAMS is required");
+    process.exit(1);
+  }
+  const upstreams = JSON.parse(rawUpstreams) as Record<string, McpUpstream>;
+  const refreshTokens: Record<string, string> = {};
+  for (const name of Object.keys(upstreams)) {
+    const token = process.env[`QUICKSTUDY_MCP_REFRESH_TOKEN_${sanitizeServerName(name)}`];
+    if (!token) {
+      console.error(`mcp-proxy: missing QUICKSTUDY_MCP_REFRESH_TOKEN_${sanitizeServerName(name)}`);
+      process.exit(1);
+    }
+    refreshTokens[name] = token;
+  }
+  startMcpProxy({
+    upstreams,
+    refreshTokens,
+    port: Number(process.env["QUICKSTUDY_MCP_PORT"] ?? 8914),
+    tokenStateDir: process.env["QUICKSTUDY_MCP_TOKEN_STATE_DIR"] ?? "/run/quickstudy-mcp",
+    onEvent: (event) => console.log(JSON.stringify(event)),
+  });
+}

package/src/isolation/mcp.ts

@@ -0,0 +1,144 @@
+/**
+ * MCP auth-proxy wiring: the pure glue between runtime-declared
+ * `McpServerConfig.auth` and the mcp-proxy sidecar (mcp-proxy/server.ts).
+ *
+ * Credentials never ride in runtime config — `auth.credentialsFile` names an
+ * env-format file the owning runtime's login tooling maintains. This module
+ * reads it (fail-fast with the operator's fix), rewrites the server map
+ * agents see (proxy URL in, real URL + auth out), and persists rotated
+ * refresh tokens back after the run — rotation means the on-disk token dies
+ * the moment the sidecar refreshes, so skipping persistence would cost the
+ * operator a re-login every run.
+ */
+
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { sanitizeServerName, type McpUpstream } from "./mcp-proxy/server.ts";
+
+/**
+ * Plain OAuth refresh-token auth config for an MCP server — the v3 shape.
+ * No secret values here: `credentialsFile` names an env-format file the
+ * owning runtime's login tooling maintains (0600, gitignored).
+ */
+export interface McpServerAuthConfig {
+  kind: "oauth-refresh";
+  /** OAuth token endpoint for the refresh grant. */
+  tokenEndpoint: string;
+  /** RFC 8707 resource indicator, when the server audience-binds tokens. */
+  resource?: string;
+  /** Absolute path to the env-format credentials file. */
+  credentialsFile: string;
+  /** Key in that file holding the OAuth client id. */
+  clientIdKey: string;
+  /** Key in that file holding the current refresh token. */
+  refreshTokenKey: string;
+}
+
+/** Plain `{url, auth}` MCP server config declared by experiment runtimes. */
+export interface McpServerConfig {
+  url: string;
+  auth?: McpServerAuthConfig;
+}
+
+/** Everything the sidecar needs: config (loggable) + secrets (never logged). */
+export interface McpAuthMaterial {
+  upstreams: Record<string, McpUpstream>;
+  /** Refresh tokens by server name — env-file-only, never argv or logs. */
+  refreshTokens: Record<string, string>;
+}
+
+/** Servers whose config carries an `auth` block. */
+export function authedMcpServers<T extends McpServerConfig>(servers: Record<string, T>): Record<string, T> {
+  return Object.fromEntries(Object.entries(servers).filter(([, spec]) => spec.auth !== undefined));
+}
+
+function parseEnvFile(content: string): Map<string, string> {
+  const values = new Map<string, string>();
+  for (const line of content.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0 && !line.trimStart().startsWith("#")) values.set(line.slice(0, eq).trim(), line.slice(eq + 1).trim());
+  }
+  return values;
+}
+
+/**
+ * Read every authed server's credentials file into sidecar material.
+ * Failures are fail-fast and actionable: a missing file or key means the
+ * operator has not run the owning login tooling (or its token store
+ * moved) — starting the run would burn attempts on guaranteed auth errors.
+ */
+export function readMcpAuthMaterialFromConfig(servers: Record<string, McpServerConfig>): McpAuthMaterial {
+  const upstreams: Record<string, McpUpstream> = {};
+  const refreshTokens: Record<string, string> = {};
+  const sanitized = new Map<string, string>();
+
+  for (const [name, spec] of Object.entries(servers)) {
+    const auth = spec.auth;
+    if (!auth) continue;
+
+    const clash = sanitized.get(sanitizeServerName(name));
+    if (clash !== undefined) {
+      throw new Error(`mcp servers "${clash}" and "${name}" collide after name sanitization — rename one`);
+    }
+    sanitized.set(sanitizeServerName(name), name);
+
+    if (!existsSync(auth.credentialsFile)) {
+      throw new Error(
+        `mcp server "${name}": credentials file ${auth.credentialsFile} does not exist — ` +
+          `run the owning runtime's MCP login tooling to create it, or deselect the MCP-treatment experiment`,
+      );
+    }
+    const values = parseEnvFile(readFileSync(auth.credentialsFile, "utf8"));
+    const clientId = values.get(auth.clientIdKey);
+    const refreshToken = values.get(auth.refreshTokenKey);
+    if (!clientId || !refreshToken) {
+      throw new Error(
+        `mcp server "${name}": ${auth.credentialsFile} lacks ${auth.clientIdKey} and/or ${auth.refreshTokenKey} — ` +
+          `re-run the owning runtime's MCP login tooling`,
+      );
+    }
+    upstreams[name] = {
+      url: spec.url,
+      tokenEndpoint: auth.tokenEndpoint,
+      clientId,
+      ...(auth.resource !== undefined ? { resource: auth.resource } : {}),
+    };
+    refreshTokens[name] = refreshToken;
+  }
+  return { upstreams, refreshTokens };
+}
+
+/**
+ * The server map agents actually see: authed servers point at the sidecar
+ * (`<proxyBase>/<name>`), auth blocks are stripped everywhere — adapters
+ * render vendor config from this and must never carry credential material.
+ */
+export function rewriteMcpServerConfigs(
+  servers: Record<string, McpServerConfig>,
+  proxyBase: string,
+): Record<string, McpServerConfig> {
+  return Object.fromEntries(
+    Object.entries(servers).map(([name, spec]) => [
+      name,
+      { url: spec.auth !== undefined ? `${proxyBase}/${encodeURIComponent(name)}` : spec.url },
+    ]),
+  );
+}
+
+/**
+ * Write a rotated refresh token back to its credentials file, preserving
+ * every other line. 0600 like the login tooling that created it.
+ */
+export function persistRotatedRefreshToken(spec: McpServerConfig, rotatedToken: string): void {
+  const auth = spec.auth;
+  if (!auth) return;
+  const lines = existsSync(auth.credentialsFile) ? readFileSync(auth.credentialsFile, "utf8").split("\n") : [];
+  const prefix = `${auth.refreshTokenKey}=`;
+  const index = lines.findIndex((line) => line.startsWith(prefix));
+  if (index >= 0) lines[index] = `${prefix}${rotatedToken}`;
+  else {
+    while (lines.at(-1) === "") lines.pop();
+    lines.push(`${prefix}${rotatedToken}`, "");
+  }
+  writeFileSync(auth.credentialsFile, lines.join("\n"), { encoding: "utf8", mode: 0o600 });
+  chmodSync(auth.credentialsFile, 0o600);
+}