Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
19.1 KB
Raw Blame
import assert from "node:assert/strict";
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { register } from "node:module";
import { tmpdir } from "node:os";
import { join } from "node:path";
import test from "node:test";

const hooks = `
export function resolve(specifier, context, next) {
  if (specifier === "electron") return { url: "electron-stub:login-sync", shortCircuit: true };
  if (specifier === "node:child_process") return { url: "keychain-stub:login-sync", shortCircuit: true };
  return next(specifier, context);
}
export function load(url, context, next) {
  if (url === "electron-stub:login-sync") return { format: "module", source: "export const session = { fromPartition() { throw new Error('unused'); } };", shortCircuit: true };
  if (url === "keychain-stub:login-sync") return { format: "module", source: "export const calls = []; export function execFile(file, args, options, callback) { calls.push({ file, args, options }); callback(null, 'synthetic-keychain-password', ''); }", shortCircuit: true };
  return next(url, context);
}
`;
register(`data:text/javascript,${encodeURIComponent(hooks)}`);
const { createBrowserLoginSync } = await import("./browser-login-sync.mjs");
// @ts-expect-error The registered test-only child-process stub exports its witness.
const { calls: keychainCalls } = await import("node:child_process");

const NOW = Date.UTC(2026, 8, 4);
const nowSeconds = Math.trunc(NOW / 1000);

function firefoxDatabase(rows, shouldFail, queries) {
  if (shouldFail()) throw new Error("read-failed");
  return {
    prepare(sql) {
      return {
        all(...params) {
          queries.push({ sql, params });
          if (sql.startsWith("PRAGMA table_info")) {
            return ["id", "originAttributes", "name", "value", "host", "path", "expiry", "lastAccessed", "isSecure", "isHttpOnly", "sameSite"].map((name) => ({ name }));
          }
          let selected = rows().filter((row) => row.originAttributes === "");
          if (sql.includes("isHttpOnly = 1")) selected = selected.filter((row) => row.isHttpOnly === 1);
          if (params.length > 0) {
            const sites = params.filter((_value, index) => index % 3 === 0).map(String);
            selected = selected.filter((row) => sites.some((site) => {
              const host = String(row.host).replace(/^\./, "");
              return host === site || host.endsWith(`.${site}`);
            }));
          }
          return selected;
        },
      };
    },
    close() {},
  };
}

function fakeSession() {
  const store = new Map();
  const key = (cookie) => `${cookie.domain}|${cookie.path}|${cookie.name}`;
  return {
    store,
    cleared: [],
    cookies: {
      async set(details) {
        const domain = details.domain ?? new URL(details.url).hostname;
        store.set(key({ domain, path: details.path, name: details.name }), { ...details, domain, hostOnly: details.domain === undefined });
      },
      async get() { return [...store.values()]; },
      async remove(url, name) {
        const hostname = new URL(url).hostname;
        for (const [entry, cookie] of store) {
          if (cookie.name === name && hostname === cookie.domain.replace(/^\./, "")) store.delete(entry);
        }
      },
      async flushStore() {},
    },
    async clearStorageData(options) {
      this.cleared.push(options ?? "all");
      if (!options) store.clear();
    },
  };
}

function setup({ pollIntervalMs = 0, watchSource = null } = {}) {
  const home = mkdtempSync(join(tmpdir(), "omnirush-login-sync-"));
  const profileDirectory = join(home, "Library", "Application Support", "Firefox", "Profiles", "chosen");
  mkdirSync(profileDirectory, { recursive: true });
  const cookiesPath = join(profileDirectory, "cookies.sqlite");
  writeFileSync(cookiesPath, "synthetic source remains unchanged");
  const statePath = join(home, "omnirush", "browser-login-sync.json");
  let sourceRows = [
    { originAttributes: "", name: "sid", value: "first-secret", host: ".example.com", path: "/", expiry: nowSeconds + 3600, lastAccessed: (nowSeconds - 10) * 1e6, isSecure: 1, isHttpOnly: 1, sameSite: 1 },
    { originAttributes: "", name: "theme", value: "dark", host: "app.example.com", path: "/", expiry: nowSeconds + 3600, lastAccessed: 0, isSecure: 0, isHttpOnly: 0, sameSite: 0 },
    { originAttributes: "", name: "auth", value: "bank-secret", host: ".bank.example", path: "/", expiry: nowSeconds + 3600, lastAccessed: (nowSeconds - 20) * 1e6, isSecure: 1, isHttpOnly: 1, sameSite: 2 },
  ];
  let failRead = false;
  let confirmationAllowed = true;
  const queries = [];
  const confirmations = [];
  const browserSession = fakeSession();
  const createService = () => createBrowserLoginSync({
      platform: "darwin",
      home,
      env: {},
      statePath,
      openDatabase: () => firefoxDatabase(() => sourceRows, () => failRead, queries),
      readKeychainPassword: async () => { throw new Error("keychain must not be touched for Firefox"); },
      getSession: () => browserSession,
      now: () => NOW,
      pollIntervalMs,
      watchSource,
      confirmUserAction: async (input) => {
        confirmations.push(input);
        return confirmationAllowed;
      },
    });
  const logins = createService();
  return {
    home,
    logins,
    browserSession,
    cookiesPath,
    statePath,
    rows: () => sourceRows,
    setRows: (rows) => { sourceRows = rows; },
    setFailRead: (value) => { failRead = value; },
    setConfirmationAllowed: (value) => { confirmationAllowed = value; },
    queries,
    confirmations,
    createService,
  };
}

async function eventuallyValue(read, matches, timeoutMs = 1_000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const value = await read();
    if (matches(value)) return value;
    await new Promise((resolve) => setTimeout(resolve, 10));
  }
  throw new Error("Timed out waiting for the sync worker.");
}

async function configureExample(logins) {
  await logins.setPolicyAllowed(true);
  const source = (await logins.listSources()).profiles.find((candidate) => candidate.browser === "firefox");
  if (!source) throw new Error("The synthetic Firefox profile was not discovered.");
  const preview = await logins.preview({ sourceId: source.id });
  return { preview, result: await logins.configure({ previewId: preview.previewId, sites: ["example.com"] }) };
}

test("policy permission does not read or configure a source", async () => {
  const { logins, confirmations, queries } = setup();
  await assert.rejects(logins.listSources(), /unavailable/);
  await assert.rejects(logins.preview({ sourceId: "firefox:chosen" }), /unavailable/);
  assert.deepEqual(await logins.getState(), {
    policyAllowed: false,
    configured: false,
    active: false,
    source: null,
    selectedSites: [],
    status: "policy_off",
    lastSyncedAt: null,
    errorCode: null,
    managedCookieCount: 0,
  });
  const permitted = await logins.setPolicyAllowed(true);
  assert.equal(permitted.configured, false);
  assert.equal(permitted.active, false);
  assert.deepEqual(confirmations, []);
  assert.deepEqual(queries, []);
  logins.shutdown();
});

test("denying the user-presence confirmation prevents the first source read", async () => {
  const fixture = setup();
  await fixture.logins.setPolicyAllowed(true);
  const source = (await fixture.logins.listSources()).profiles.find((candidate) => candidate.browser === "firefox");
  if (!source) throw new Error("The synthetic Firefox profile was not discovered.");
  fixture.setConfirmationAllowed(false);
  await assert.rejects(fixture.logins.preview({ sourceId: source.id }), /cancelled/);
  assert.deepEqual(fixture.confirmations.map((entry) => entry.action), ["discover", "read"]);
  assert.deepEqual(fixture.queries, []);
  fixture.logins.shutdown();
});

test("setup exposes no values, keeps sensitive sites unchecked, and reads values only for selected HttpOnly hosts", async () => {
  const { logins, browserSession, statePath, queries, confirmations } = setup();
  const { preview, result } = await configureExample(logins);

  assert.deepEqual(preview.sites.map((site) => [site.site, site.category, site.preselected]), [
    ["example.com", "ordinary", true],
    ["bank.example", "finance", false],
  ]);
  assert.equal(JSON.stringify(preview).includes("first-secret"), false);
  const previewSelect = queries.find((entry) => entry.sql.startsWith("SELECT host, name, path"));
  assert.ok(previewSelect, "preview uses the metadata-only query");
  assert.equal(previewSelect.sql.includes(" value"), false);
  const selectedValueRead = queries.find((entry) => entry.sql.startsWith("SELECT host, name, value"));
  assert.ok(selectedValueRead?.sql.includes("host = ?"), "the value query is scoped to selected hosts");
  assert.ok(selectedValueRead?.sql.includes("isHttpOnly = 1"), "the value query excludes page-readable cookies");
  assert.deepEqual(selectedValueRead?.params.filter((_value, index) => index % 3 === 0), ["example.com"]);
  assert.deepEqual(confirmations.map((entry) => entry.action), ["discover", "read", "configure"]);
  assert.deepEqual(confirmations[2].sites, ["example.com"]);
  assert.deepEqual(result, { sites: [{ site: "example.com", synced: 1, failed: 0, removed: 0 }] });
  assert.deepEqual((await browserSession.cookies.get()).map((cookie) => [cookie.domain, cookie.name]), [[".example.com", "sid"]]);

  const state = await logins.getState();
  assert.equal(state.active, true);
  assert.equal(state.status, "synced");
  assert.deepEqual(state.selectedSites, ["example.com"]);
  assert.equal(state.managedCookieCount, 1);
  const persisted = readFileSync(statePath, "utf8");
  assert.equal(persisted.includes("first-secret"), false);
  assert.equal(persisted.includes("bank-secret"), false);
  logins.shutdown();
});

test("Chrome setup looks up the Keychain service rather than its account name", async (t) => {
  const home = mkdtempSync(join(tmpdir(), "omnirush-login-sync-chrome-"));
  t.after(() => rmSync(home, { recursive: true, force: true }));
  const profile = join(home, "Library", "Application Support", "Google", "Chrome", "Default");
  mkdirSync(profile, { recursive: true });
  writeFileSync(join(profile, "Cookies"), "synthetic Chrome source");
  const row = {
    host_key: ".example.com", name: "sid", value: "chrome-fixture", encrypted_value: Buffer.alloc(0),
    path: "/", is_secure: 1, is_httponly: 1, samesite: 1, has_expires: 0, is_persistent: 0,
    expires_utc: 0, last_access_utc: 0,
  };
  const browserSession = fakeSession();
  const logins = createBrowserLoginSync({
    platform: "darwin", home, env: {}, initialPolicyAllowed: true,
    pollIntervalMs: 0, watchSource: null, getSession: () => browserSession,
    openDatabase: () => ({
      prepare(sql) {
        return { all() {
          if (sql.startsWith("PRAGMA table_info")) return Object.keys(row).map((name) => ({ name }));
          if (sql.includes("FROM meta")) return [{ value: "23" }];
          return [row];
        } };
      },
      close() {},
    }),
  });
  t.after(() => logins.shutdown());
  keychainCalls.length = 0;
  const source = (await logins.listSources()).profiles.find((entry) => entry.browser === "chrome");
  assert.ok(source);
  const preview = await logins.preview({ sourceId: source.id });
  assert.deepEqual(keychainCalls, [], "metadata preview never requests a password");
  await logins.configure({ previewId: preview.previewId, sites: ["example.com"] });
  assert.deepEqual(keychainCalls, [{
    file: "/usr/bin/security",
    args: ["find-generic-password", "-w", "-s", "Chrome Safe Storage"],
    options: { timeout: 120_000 },
  }]);
  assert.equal((await browserSession.cookies.get())[0].value, "chrome-fixture");
});

for (const revocation of ["disconnect", "stopSite", "pause"]) {
  for (const writeSucceeds of [true, false]) {
    test(`${revocation} retains all installed cookies for forgetting when a pending write ${writeSucceeds ? "succeeds" : "fails"}`, { timeout: 5_000 }, async (t) => {
      const fixture = setup();
      t.after(() => { fixture.logins.shutdown(); rmSync(fixture.home, { recursive: true, force: true }); });
      await configureExample(fixture.logins);
      const cookies = fixture.browserSession.cookies;
      for (const [host, name] of [["bank.example", "sid"], ["example.com", "direct"], ["example.com", "pending"], ["example.com", "unattempted"]]) {
        await cookies.set({ url: `https://${host}/`, domain: `.${host}`, path: "/", name, value: "direct-fixture" });
      }
      const unrelated = (await cookies.get()).filter((cookie) => cookie.value === "direct-fixture"
        && (!writeSucceeds || cookie.name !== "pending"));
      const source = fixture.rows()[0];
      fixture.setRows(["early", "pending", "unattempted"].map((name) => ({ ...source, name })));
      let signalEntered;
      /** @type {(value?: unknown) => void} */
      let releaseWrite;
      const entered = new Promise((resolve) => { signalEntered = resolve; });
      const release = new Promise((resolve) => { releaseWrite = resolve; });
      t.after(() => releaseWrite());
      const set = cookies.set;
      const attempts = [];
      cookies.set = async (details) => {
        attempts.push(details.name);
        if (details.name === "pending") {
          signalEntered();
          await release;
          if (!writeSucceeds) throw new Error("target-write-failed");
        }
        await set(details);
      };
      const syncing = assert.rejects(fixture.logins.syncNow(), /Browser login sync failed/);
      await entered;
      let revoked = false;
      const revoke = (revocation === "disconnect" ? fixture.logins.disconnect({ forgetSynced: true })
        : revocation === "stopSite" ? fixture.logins.stopSite("example.com") : fixture.logins.pause())
        .then((result) => { revoked = true; return result; });
      await new Promise((resolve) => setImmediate(resolve));
      assert.equal(revoked, false, "revocation waits for the native write to settle");
      releaseWrite();
      await Promise.all([syncing, revoke]);
      assert.deepEqual(attempts, ["early", "pending"], "cancellation prevents later writes");
      if (revocation === "pause") {
        const installed = writeSucceeds ? 3 : 2;
        assert.equal((await fixture.logins.getState()).managedCookieCount, installed);
        assert.equal(JSON.parse(readFileSync(fixture.statePath, "utf8")).managedCookies.length, installed);
        await fixture.logins.disconnect({ forgetSynced: true });
      }
      assert.deepEqual(await cookies.get(), unrelated, "forgetting removes only successfully installed owned cookies");
      assert.equal((await fixture.logins.getState()).managedCookieCount, 0);
      assert.deepEqual(fixture.browserSession.cleared, [], "revocation never clears unrelated storage");
    });
  }
}

test("sync updates and removes managed source cookies without touching unselected sites", async () => {
  const fixture = setup();
  await configureExample(fixture.logins);
  const unchangedSource = readFileSync(fixture.cookiesPath, "utf8");

  fixture.setRows(fixture.rows().map((row) => row.name === "sid" ? { ...row, value: "rotated-secret" } : row));
  assert.deepEqual(await fixture.logins.syncNow(), { sites: [{ site: "example.com", synced: 1, failed: 0, removed: 0 }] });
  assert.equal((await fixture.browserSession.cookies.get())[0].value, "rotated-secret");

  fixture.setRows(fixture.rows().filter((row) => row.name !== "sid"));
  assert.deepEqual(await fixture.logins.syncNow(), { sites: [{ site: "example.com", synced: 0, failed: 0, removed: 1 }] });
  assert.deepEqual(await fixture.browserSession.cookies.get(), []);
  assert.equal(readFileSync(fixture.cookiesPath, "utf8"), unchangedSource);
  assert.equal(fixture.rows().some((row) => row.host === ".bank.example"), true, "the unselected source site stays untouched");
  fixture.logins.shutdown();
});

test("the background fingerprint worker follows a changed source without Sync now", async () => {
  const fixture = setup({ pollIntervalMs: 10 });
  await configureExample(fixture.logins);
  fixture.setRows(fixture.rows().map((row) => row.name === "sid" ? { ...row, value: "worker-secret" } : row));
  writeFileSync(fixture.cookiesPath, "synthetic source changed for worker");

  await eventuallyValue(
    async () => (await fixture.browserSession.cookies.get())[0]?.value,
    (value) => value === "worker-secret",
  );
  fixture.logins.shutdown();
});

test("a failed source read keeps the last good target cookie and reports only a value-free code", async () => {
  const fixture = setup();
  await configureExample(fixture.logins);
  fixture.setRows(fixture.rows().filter((row) => row.name !== "sid"));
  fixture.setFailRead(true);

  await assert.rejects(fixture.logins.syncNow(), /read_failed/);
  assert.equal((await fixture.browserSession.cookies.get())[0].value, "first-secret");
  const state = await fixture.logins.getState();
  assert.equal(state.status, "error");
  assert.equal(state.errorCode, "read_failed");
  assert.equal(JSON.stringify(state).includes("first-secret"), false);
  fixture.logins.shutdown();
});

test("pause stops reads and stopping a site prevents it from being restored", async () => {
  const fixture = setup();
  await configureExample(fixture.logins);
  await fixture.logins.pause();
  fixture.setRows(fixture.rows().map((row) => row.name === "sid" ? { ...row, value: "after-pause" } : row));

  await assert.rejects(fixture.logins.syncNow(), /paused or not configured/);
  assert.equal((await fixture.browserSession.cookies.get())[0].value, "first-secret");

  await fixture.logins.setPolicyAllowed(true);
  await fixture.logins.resume();
  assert.equal((await fixture.browserSession.cookies.get())[0].value, "after-pause");
  assert.deepEqual(await fixture.logins.stopSite("example.com"), {
    sites: [{ site: "example.com", synced: 0, failed: 0, removed: 1 }],
  });
  assert.deepEqual(await fixture.browserSession.cookies.get(), []);
  await assert.rejects(fixture.logins.resume(), /Set up browser login sync first/);
  fixture.logins.shutdown();
});

test("policy revocation stops reads but preserves copied state until the user forgets it", async () => {
  const fixture = setup();
  await configureExample(fixture.logins);
  const blocked = await fixture.logins.setPolicyAllowed(false);
  assert.equal(blocked.status, "policy_off");
  assert.equal(blocked.active, false);
  assert.equal((await fixture.browserSession.cookies.get()).length, 1);
  await assert.rejects(fixture.logins.syncNow(), /unavailable/);
  assert.equal((await fixture.browserSession.cookies.get()).length, 1);
  const reallowed = await fixture.logins.setPolicyAllowed(true);
  assert.equal(reallowed.active, false, "policy restoration cannot silently restart a revoked sync");
  await assert.rejects(fixture.logins.syncNow(), /paused or not configured/);
  fixture.logins.shutdown();
});

test("a new Desktop process restores enrollment paused instead of trusting a renderer grant", async () => {
  const fixture = setup();
  await configureExample(fixture.logins);
  fixture.logins.shutdown();

  const restarted = fixture.createService();
  const permitted = await restarted.setPolicyAllowed(true);
  assert.equal(permitted.configured, true);
  assert.equal(permitted.active, false);
  assert.equal(permitted.status, "paused");
  await assert.rejects(restarted.syncNow(), /paused or not configured/);
  restarted.shutdown();
});