Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

20.7 KB
Raw Blame
import { afterEach, expect, spyOn, test } from "bun:test";
import * as fsPromises from "node:fs/promises";
import {
  chmod,
  mkdir,
  mkdtemp,
  readFile,
  rm,
  stat,
  symlink,
  writeFile,
} from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { Hono } from "hono";
import {
  clearDesktopConnectionFailure,
  mountDesktopConnectionFailure,
} from "../src/desktop-connection-failure";
import {
  createProviderOAuthProxy,
  type ModelOAuthRecord,
  mountProviderOAuthProxy,
} from "../src/provider-oauth";
import { lockProviderCredentials } from "../src/provider-oauth-lock";

const cleanup: (() => Promise<void> | void)[] = [];
afterEach(async () => {
  try {
    for (const dispose of cleanup.splice(0).reverse()) await dispose();
  } finally {
    clearDesktopConnectionFailure("model");
  }
});

function record(overrides: Partial<ModelOAuthRecord> = {}): ModelOAuthRecord {
  return {
    version: 1,
    sessionId: "session-one",
    provider: "google",
    clientId: "desktop-client",
    clientSecret: "desktop-client-secret",
    accessToken: "provider-access-token",
    refreshToken: "provider-refresh-token",
    expiresAt: Date.now() + 3_600_000,
    scope: "model-scope",
    quotaProject: "google-quota-project",
    proxyToken: "local-proxy-token",
    ...overrides,
  };
}

async function fixture(
  current: ModelOAuthRecord,
  handler: (request: Request) => Response | Promise<Response>,
) {
  const root = await mkdtemp(join(tmpdir(), "openbot-model-oauth-"));
  cleanup.push(() => rm(root, { recursive: true, force: true }));
  const file = join(root, "model-oauth.json");
  await writeFile(file, JSON.stringify(current), { mode: 0o600 });
  const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: handler });
  cleanup.push(() => server.stop(true));
  const destinations: string[] = [];
  const app = new Hono();
  mountProviderOAuthProxy(
    app,
    createProviderOAuthProxy(file, {
      fetch: async (input, init) => {
        const url = new URL(input instanceof Request ? input.url : input);
        destinations.push(url.href);
        return fetch(new URL(url.pathname, server.url), init);
      },
    }),
  );
  mountDesktopConnectionFailure(app, "test-host-token");
  const ask = (token: string | null = current.proxyToken) =>
    app.request("/api/model-provider/v1/chat/completions", {
      method: "POST",
      headers: {
        "content-type": "application/json",
        cookie: "browser-session-must-not-pass-upstream",
        ...(token === null ? {} : { authorization: `Bearer ${token}` }),
      },
      body: JSON.stringify({
        model: "chosen-model",
        messages: [],
        stream: true,
      }),
    });
  return { app, file, ask, destinations, providerUrl: server.url };
}

test("the model proxy requires its bearer even with a browser cookie", async () => {
  const f = await fixture(record(), () => new Response("not called"));
  for (const token of [null, "wrong-token"]) {
    const response = await f.ask(token);
    expect(response.status).toBe(401);
    expect(await response.text()).not.toContain("provider-access-token");
  }
  expect(f.destinations).toEqual([]);
});

test("Google uses provider bearer and quota project while preserving streamed model output", async () => {
  const f = await fixture(record(), async (request) => {
    expect(request.headers.get("authorization")).toBe(
      "Bearer provider-access-token",
    );
    expect(request.headers.get("x-goog-user-project")).toBe(
      "google-quota-project",
    );
    expect(request.headers.get("cookie")).toBeNull();
    expect(await request.json()).toMatchObject({
      contents: [],
    });
    return new Response(
      'data: {"candidates":[{"content":{"parts":[{"text":"Hello"}]},"finishReason":"STOP"}]}\n\n',
      {
        headers: {
          "content-type": "text/event-stream",
          "set-cookie": "must-not-leave-provider",
        },
      },
    );
  });
  const response = await f.ask();
  expect(response.status).toBe(200);
  expect(response.headers.get("content-type")).toBe("text/event-stream");
  expect(response.headers.get("set-cookie")).toBeNull();
  expect(response.headers.get("cache-control")).toBe("no-store");
  expect(await response.text()).toContain("data: [DONE]");
  expect(f.destinations).toEqual([
    "https://generativelanguage.googleapis.com/v1beta/models/chosen-model:streamGenerateContent?alt=sse",
  ]);
});

test("xAI uses the existing compatible model endpoint without Google quota headers", async () => {
  const f = await fixture(
    record({ provider: "xai", quotaProject: undefined }),
    (request) => {
      expect(request.headers.get("authorization")).toBe(
        "Bearer provider-access-token",
      );
      expect(request.headers.get("x-goog-user-project")).toBeNull();
      return Response.json({ choices: [] });
    },
  );
  expect((await f.ask()).status).toBe(200);
  expect(f.destinations).toEqual(["https://api.x.ai/v1/chat/completions"]);
});

test("concurrent requests refresh once and persist the rotated pair before forwarding", async () => {
  let refreshes = 0;
  const f = await fixture(record({ expiresAt: 1 }), async (request) => {
    if (new URL(request.url).pathname === "/token") {
      refreshes++;
      const body = new URLSearchParams(await request.text());
      expect(body.get("grant_type")).toBe("refresh_token");
      expect(body.get("refresh_token")).toBe("provider-refresh-token");
      expect(body.get("client_id")).toBe("desktop-client");
      expect(body.get("client_secret")).toBe("desktop-client-secret");
      await Bun.sleep(20);
      return Response.json({
        access_token: "rotated-access",
        refresh_token: "rotated-refresh",
        expires_in: 3600,
      });
    }
    expect(request.headers.get("authorization")).toBe("Bearer rotated-access");
    const saved = JSON.parse(await readFile(f.file, "utf8"));
    expect(saved.refreshToken).toBe("rotated-refresh");
    return new Response(
      'data: {"candidates":[{"content":{"parts":[{"text":"Refreshed"}]},"finishReason":"STOP"}]}\n\n',
      { headers: { "content-type": "text/event-stream" } },
    );
  });
  const responses = await Promise.all(Array.from({ length: 8 }, () => f.ask()));
  expect(responses.map((response) => response.status)).toEqual(
    Array(8).fill(200),
  );
  for (const response of responses)
    expect(await response.text()).toContain("data: [DONE]");
  expect(refreshes).toBe(1);
  const saved = JSON.parse(await readFile(f.file, "utf8"));
  expect(saved).toMatchObject({
    accessToken: "rotated-access",
    refreshToken: "rotated-refresh",
    sessionId: "session-one",
  });
  expect(saved.expiresAt).toBeGreaterThan(Date.now());
  if (process.platform !== "win32")
    expect((await stat(f.file)).mode & 0o777).toBe(0o600);
  expect((await f.ask()).status).toBe(200);
  expect(refreshes).toBe(1);
});

test("invalid Google requests are rejected before forwarding the provider bearer", async () => {
  const f = await fixture(record(), () => new Response("must not be called"));
  const response = await f.app.request(
    "/api/model-provider/v1/chat/completions",
    {
      method: "POST",
      headers: {
        authorization: "Bearer local-proxy-token",
        "content-type": "application/json",
      },
      body: JSON.stringify({ model: "../outside", messages: [] }),
    },
  );
  expect(response.status).toBe(400);
  expect(f.destinations).toEqual([]);
});

test("an unexpired rejected xAI token is refreshed once and the request is replayed", async () => {
  let refreshes = 0;
  let calls = 0;
  const f = await fixture(
    record({
      provider: "xai",
      quotaProject: undefined,
      clientSecret: undefined,
    }),
    async (request) => {
      if (new URL(request.url).pathname === "/oauth2/token") {
        refreshes++;
        const body = new URLSearchParams(await request.text());
        expect(body.get("client_secret")).toBeNull();
        return Response.json({
          access_token: "new-xai-token",
          expires_in: 3600,
        });
      }
      calls++;
      return request.headers.get("authorization") === "Bearer new-xai-token"
        ? Response.json({ choices: [] })
        : Response.json({ error: "expired" }, { status: 401 });
    },
  );
  expect((await f.ask()).status).toBe(200);
  expect(refreshes).toBe(1);
  expect(calls).toBe(2);
  expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
    "provider-refresh-token",
  );
});

test("a refused refresh exposes no provider response or credential and keeps the old file", async () => {
  const initial = record({ expiresAt: 1 });
  const f = await fixture(initial, () =>
    Response.json(
      { error: "invalid_grant", secret: initial.refreshToken },
      { status: 400 },
    ),
  );
  const response = await f.ask();
  expect(response.status).toBe(401);
  const body = await response.text();
  expect(body).not.toContain(initial.refreshToken);
  expect(body).not.toContain("invalid_grant");
  expect(JSON.parse(await readFile(f.file, "utf8"))).toEqual(initial);
});

test.each(["model", "refresh"] as const)(
  "%s endpoint redirects cannot carry provider credentials elsewhere",
  async (endpoint) => {
    let leaked = 0;
    const destination = Bun.serve({
      hostname: "127.0.0.1",
      port: 0,
      fetch: () => {
        leaked++;
        return new Response("leaked");
      },
    });
    cleanup.push(() => destination.stop(true));
    const f = await fixture(
      record({
        expiresAt: endpoint === "refresh" ? 1 : Date.now() + 3_600_000,
      }),
      () => Response.redirect(destination.url, 307),
    );
    const response = await f.ask();
    expect(response.status).toBe(endpoint === "refresh" ? 401 : 502);
    expect(response.headers.get("location")).toBeNull();
    expect(leaked).toBe(0);
  },
);

test("a completed new sign-in cannot be overwritten by an older in-flight refresh", async () => {
  let began!: () => void;
  let finish!: () => void;
  const started = new Promise<void>((resolve) => {
    began = resolve;
  });
  const release = new Promise<void>((resolve) => {
    finish = resolve;
  });
  const f = await fixture(record({ expiresAt: 1 }), async () => {
    began();
    await release;
    return Response.json({
      access_token: "old-session-rotated-access",
      refresh_token: "old-session-rotated-refresh",
      expires_in: 3600,
    });
  });
  const pending = f.ask();
  await started;
  const replacement = record({
    sessionId: "new-sign-in",
    proxyToken: "new-local-token",
    refreshToken: "new-sign-in-refresh",
  });
  await writeFile(f.file, JSON.stringify(replacement), { mode: 0o600 });
  finish();
  expect((await pending).status).toBe(401);
  expect(JSON.parse(await readFile(f.file, "utf8"))).toEqual(replacement);
});

test("missing or malformed credential files fail closed without exposing their content", async () => {
  const f = await fixture(record(), () => new Response("not called"));
  await writeFile(f.file, '{"accessToken":"malformed-private-token"');
  let response = await f.ask();
  expect(response.status).toBe(503);
  expect(await response.text()).not.toContain("malformed-private-token");
  await rm(f.file);
  response = await f.ask();
  expect(response.status).toBe(503);
  expect(f.destinations).toEqual([]);
});

async function authenticationFailure(app: Hono) {
  const response = await app.request("/api/desktop/connection-failure", {
    headers: { "x-openbot-desktop-host-token": "test-host-token" },
  });
  return response.json();
}

test("an abandoned legacy lock directory does not consume and lose a rotated token", async () => {
  let exchanges = 0;
  const f = await fixture(record({ provider: "xai", expiresAt: 1 }), () => {
    exchanges++;
    return Response.json({
      access_token: "next",
      refresh_token: "next-refresh",
      expires_in: 3600,
    });
  });
  const child = await lockOwner(f.file, "legacy");
  // The former Rust create_dir used the process umask (commonly 0755).
  if (process.platform !== "win32") await chmod(`${f.file}.lock`, 0o755);
  child.kill("SIGKILL");
  await child.exited;
  const response = await f.ask();
  expect(response.status).toBe(200);
  expect(exchanges).toBe(2); // One refresh and one model request.
  expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
    "next-refresh",
  );
}, 10000);

test("independent proxy instances serialize real rotating-token exchanges", async () => {
  let exchanges = 0;
  const initial = record({ provider: "xai", expiresAt: 1 });
  const f = await fixture(initial, async (request) => {
    if (new URL(request.url).pathname === "/oauth2/token") {
      const exchange = ++exchanges;
      await Bun.sleep(50);
      return exchange === 1
        ? Response.json({
            access_token: "next",
            refresh_token: "next-refresh",
            expires_in: 3600,
          })
        : Response.json({ error: "already spent" }, { status: 400 });
    }
    return Response.json({ choices: [] });
  });
  // Each separate Hono/proxy instance has its own in-memory refresh deduplication map.
  const other = createProviderOAuthProxy(f.file, {
    fetch: async (input, init) => {
      const url = new URL(input instanceof Request ? input.url : input);
      return fetch(new URL(url.pathname, f.providerUrl), init);
    },
  });
  const responses = await Promise.all([
    f.ask(),
    other(
      new Request("http://localhost/model", {
        method: "POST",
        headers: { authorization: `Bearer ${initial.proxyToken}` },
        body: JSON.stringify({ model: "model", messages: [] }),
      }),
    ),
  ]);
  expect(responses.map((response) => response.status)).toEqual([200, 200]);
  expect(exchanges).toBe(1);
});

test("an unreadable request body does not invalidate provider sign-in", async () => {
  const f = await fixture(record(), () => new Response("must not be called"));
  const response = await f.app.request(
    "/api/model-provider/v1/chat/completions",
    {
      method: "POST",
      headers: { authorization: "Bearer local-proxy-token" },
      body: new ReadableStream({
        start(controller) {
          controller.error(new Error("client disconnected"));
        },
      }),
    },
  );
  expect(response.status).toBe(400);
  expect(f.destinations).toEqual([]);
  expect(await authenticationFailure(f.app)).toBeNull();
});

test("a quota-project permission denial stays 403 without invalidating sign-in", async () => {
  const f = await fixture(record(), () =>
    Response.json({ error: "private quota project detail" }, { status: 403 }),
  );
  const response = await f.ask();
  expect(response.status).toBe(403);
  expect(await response.text()).not.toContain("private quota project detail");
  expect(await authenticationFailure(f.app)).toBeNull();
  expect(f.destinations).toHaveLength(1);
});

test("credential file paths must be absolute", () => {
  expect(() => createProviderOAuthProxy("relative.json")).toThrow("absolute");
});

test.each(["world-readable", "symlink", "oversized", "missing-quota"] as const)(
  "%s credential files are refused before provider I/O",
  async (kind) => {
    if (kind === "world-readable" && process.platform === "win32") return;
    const f = await fixture(record(), () => new Response("must not be called"));
    if (kind === "world-readable") await chmod(f.file, 0o644);
    if (kind === "symlink") {
      const target = `${f.file}.target`;
      await writeFile(target, JSON.stringify(record()), { mode: 0o600 });
      await rm(f.file);
      await symlink(target, f.file);
    }
    if (kind === "oversized")
      await writeFile(
        f.file,
        JSON.stringify(record({ scope: "x".repeat(64 * 1024) })),
      );
    if (kind === "missing-quota")
      await writeFile(
        f.file,
        JSON.stringify(record({ quotaProject: undefined })),
      );
    const response = await f.ask();
    expect(response.status).toBe(503);
    expect(f.destinations).toEqual([]);
    expect(await response.text()).not.toContain("provider-refresh-token");
  },
);

async function lockOwner(file: string, mode?: "legacy") {
  const child = Bun.spawn(
    [
      process.execPath,
      fileURLToPath(
        new URL("./fixtures/provider-oauth-lock-owner.ts", import.meta.url),
      ),
      file,
      ...(mode ? [mode] : []),
    ],
    {
      stdin: "pipe",
      stdout: "pipe",
      stderr: "pipe",
    },
  );
  cleanup.push(async () => {
    child.kill();
    await child.exited;
  });
  const reader = child.stdout.getReader();
  const timeout = setTimeout(() => child.kill(), 15000);
  try {
    let message = "";
    while (!message.includes("\n")) {
      const { value, done } = await reader.read();
      if (done)
        throw new Error(
          `Lock owner exited: ${await new Response(child.stderr).text()}`,
        );
      message += new TextDecoder().decode(value);
    }
    expect(message.trim()).toBe("locked");
  } finally {
    clearTimeout(timeout);
    reader.releaseLock();
  }
  return child;
}

test("killing a real lock owner permits a subsequent durable rotating-token exchange", async () => {
  let refreshes = 0;
  const f = await fixture(
    record({ provider: "xai", expiresAt: 1 }),
    (request) => {
      if (new URL(request.url).pathname === "/oauth2/token") {
        refreshes++;
        return Response.json({
          access_token: "recovered",
          refresh_token: "recovered-refresh",
          expires_in: 3600,
        });
      }
      return Response.json({ choices: [] });
    },
  );
  const child = await lockOwner(f.file);
  child.kill("SIGKILL");
  await child.exited;
  expect((await f.ask()).status).toBe(200);
  expect(refreshes).toBe(1);
  expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
    "recovered-refresh",
  );
}, 20000);

test("a live lock owner prevents any provider exchange until ownership is obtained", async () => {
  let refreshes = 0;
  const f = await fixture(
    record({ provider: "xai", expiresAt: 1 }),
    (request) => {
      if (new URL(request.url).pathname === "/oauth2/token") {
        refreshes++;
        return Response.json({
          access_token: "next",
          refresh_token: "next-refresh",
          expires_in: 3600,
        });
      }
      return Response.json({ choices: [] });
    },
  );
  const child = await lockOwner(f.file);
  const pending = f.ask();
  await Bun.sleep(100);
  expect(refreshes).toBe(0);
  child.stdin.end();
  expect(await child.exited).toBe(0);
  expect((await pending).status).toBe(200);
  expect(refreshes).toBe(1);
}, 20000);

test("a lock timeout returns a retryable failure without consuming a refresh token or recording an auth failure", async () => {
  const f = await fixture(
    record({ expiresAt: 1 }),
    () => new Response("must not be called"),
  );
  const unlock = await lockProviderCredentials(f.file);
  try {
    expect((await f.ask()).status).toBe(503);
    expect(f.destinations).toEqual([]);
    expect(await authenticationFailure(f.app)).toBeNull();
    expect(JSON.parse(await readFile(f.file, "utf8")).refreshToken).toBe(
      "provider-refresh-token",
    );
  } finally {
    await unlock();
  }
}, 20000);

test("a redirected lock inode is rejected before a provider exchange", async () => {
  const f = await fixture(
    record({ expiresAt: 1 }),
    () => new Response("must not be called"),
  );
  await mkdir(`${f.file}.lock`, { mode: 0o700 });
  const target = `${f.file}.untouched`;
  await writeFile(target, "untouched", { mode: 0o600 });
  await symlink(target, join(`${f.file}.lock`, "owner.lock"));
  expect((await f.ask()).status).toBe(503);
  expect(f.destinations).toEqual([]);
  expect(await readFile(target, "utf8")).toBe("untouched");
});

test("Windows validates the opened credential identity before reading a replaced path", async () => {
  const f = await fixture(record({ provider: "xai" }), () =>
    Response.json({ choices: [] }),
  );
  const originalPlatform = Object.getOwnPropertyDescriptor(
    process,
    "platform",
  )!;
  const before = await fsPromises.lstat(f.file, { bigint: true });
  const replacement = `${f.file}.replacement`;
  await writeFile(
    replacement,
    JSON.stringify(
      record({ provider: "xai", accessToken: "must-not-be-forwarded" }),
    ),
    { mode: 0o600 },
  );
  // Return the real metadata sampled before another writer atomically replaced
  // the path: a deterministic race between Windows lstat and open.
  Object.defineProperty(process, "platform", {
    value: "win32",
    configurable: true,
  });
  try {
    expect((await f.ask()).status).toBe(200); // Valid file identities still work.
    f.destinations.length = 0;
    await fsPromises.rename(replacement, f.file);
    const inspect = spyOn(fsPromises, "lstat").mockResolvedValue(before);
    try {
      expect((await f.ask()).status).toBe(503);
      expect(f.destinations).toEqual([]);
    } finally {
      inspect.mockRestore();
    }
  } finally {
    Object.defineProperty(process, "platform", originalPlatform);
  }
});