Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

21.4 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");
const http = require("node:http");
const net = require("node:net");
const Module = require("node:module");

const loopbackModulePath = require.resolve("../../src/helpers/oauthLoopbackFlow.js");
const originalLoad = Module._load;

function loadLoopback() {
  delete require.cache[loopbackModulePath];
  Module._load = function loadWithElectronMock(request, parent, isMain) {
    if (request === "electron") {
      return { shell: { openExternal() {} } };
    }
    return originalLoad.call(this, request, parent, isMain);
  };
  try {
    return require(loopbackModulePath);
  } finally {
    Module._load = originalLoad;
  }
}

function startFlow(handleCallback = async () => ({ ok: true }), options = {}) {
  const { runOAuthLoopbackFlow } = loadLoopback();
  let redirectUri;
  let state;
  let authUrlCalls = 0;
  let server;
  const originalCreateServer = http.createServer;
  http.createServer = (...args) => {
    server = originalCreateServer(...args);
    return server;
  };

  try {
    const flow = runOAuthLoopbackFlow({
      errorParam: "gcal_error",
      ...options,
      buildAuthUrl: (uri, flowState) => {
        redirectUri = uri;
        state = flowState;
        authUrlCalls += 1;
        return "https://example.test/auth";
      },
      handleCallback,
    });
    return {
      flow,
      server,
      getRedirectUri: () => redirectUri,
      getState: () => state,
      getAuthUrlCalls: () => authUrlCalls,
    };
  } finally {
    http.createServer = originalCreateServer;
  }
}

function startBlockedFlow() {
  let callbackCount = 0;
  let releaseHandleCallback;
  let markCallbackStarted;
  const callbackStarted = new Promise((resolve) => {
    markCallbackStarted = resolve;
  });
  const startedFlow = startFlow(async (code) => {
    callbackCount += 1;
    if (callbackCount === 1) {
      markCallbackStarted();
      await new Promise((resolve) => {
        releaseHandleCallback = resolve;
      });
    }
    return { code };
  });

  return {
    ...startedFlow,
    callbackStarted,
    getCallbackCount: () => callbackCount,
    releaseHandleCallback: () => releaseHandleCallback?.(),
  };
}

function startFlowWithControlledTimeout(handleCallback) {
  const originalSetTimeout = global.setTimeout;
  let runFlowTimeout;

  global.setTimeout = (callback, delay, ...args) => {
    if (delay === 120000) {
      runFlowTimeout = () => callback(...args);
      return originalSetTimeout(() => {}, 0);
    }
    return originalSetTimeout(callback, delay, ...args);
  };

  try {
    const startedFlow = startFlow(handleCallback);
    return {
      ...startedFlow,
      triggerTimeout: () => {
        if (!runFlowTimeout) throw new Error("OAuth timeout was not scheduled");
        runFlowTimeout();
      },
    };
  } finally {
    global.setTimeout = originalSetTimeout;
  }
}

async function waitForListen(getRedirectUri) {
  for (let i = 0; i < 50; i++) {
    if (getRedirectUri()) return getRedirectUri();
    await new Promise((resolve) => setTimeout(resolve, 10));
  }
  throw new Error("loopback server did not start");
}

function requestPath(redirectUri, path) {
  const { hostname, port } = new URL(redirectUri);
  return new Promise((resolve, reject) => {
    const request = http.get(
      { hostname, port, path, agent: false, headers: { Connection: "close" } },
      (response) => {
        response.resume();
        response.on("end", () => resolve(response.statusCode));
      }
    );
    request.on("error", reject);
  });
}

async function parkPartialRequest(redirectUri, server) {
  const { hostname, port } = new URL(redirectUri);
  let response = "";
  let responseStatus;
  let responseSettled = false;
  let resolveStatus;
  let rejectStatus;
  const status = new Promise((resolve, reject) => {
    resolveStatus = resolve;
    rejectStatus = reject;
  });
  const requestStarted = new Promise((resolve) => {
    server.once("connection", (acceptedSocket) => {
      acceptedSocket.once("data", resolve);
    });
  });
  const socket = net.createConnection({ host: hostname, port });
  socket.setEncoding("utf8");
  socket.on("data", (chunk) => {
    response += chunk;
    const match = /^HTTP\/1\.1 (\d{3})/.exec(response);
    if (match) {
      responseStatus = Number(match[1]);
    }
  });
  socket.on("end", () => {
    if (responseStatus && !responseSettled) {
      responseSettled = true;
      resolveStatus(responseStatus);
    }
  });
  socket.on("error", (error) => {
    if (!responseSettled) {
      responseSettled = true;
      rejectStatus(error);
    }
  });
  socket.on("close", () => {
    if (!responseSettled) {
      responseSettled = true;
      rejectStatus(new Error("parked request closed without a response"));
    }
  });

  await new Promise((resolve, reject) => {
    const handleConnect = () => {
      socket.off("error", handleError);
      resolve();
    };
    const handleError = (error) => {
      socket.off("connect", handleConnect);
      reject(error);
    };
    socket.once("connect", handleConnect);
    socket.once("error", handleError);
  });
  socket.write("GET /");
  await requestStarted;

  return {
    complete: (path) => {
      socket.end(`${path} HTTP/1.1\r\nHost: ${hostname}:${port}\r\nConnection: close\r\n\r\n`);
      return status;
    },
    destroy: () => socket.destroy(),
  };
}

test("a callback with a code and the wrong state rejects immediately", async () => {
  const { flow, getRedirectUri } = startFlow();
  const redirectUri = await waitForListen(getRedirectUri);
  const started = Date.now();
  const rejected = assert.rejects(flow, /OAuth state mismatch/);

  const response = await fetch(`${redirectUri}/?code=stolen&state=wrong`, {
    redirect: "manual",
  });
  assert.equal(response.status, 400);

  await rejected;
  assert.ok(Date.now() - started < 5000, "must not wait for the 120s timeout");
});

test("a request with no code leaves the flow running until a real callback", async () => {
  const { flow, getRedirectUri, getState } = startFlow(async (code) => ({ code }));
  const redirectUri = await waitForListen(getRedirectUri);

  const stray = await fetch(`${redirectUri}/favicon.ico`, { redirect: "manual" });
  assert.equal(stray.status, 400);

  const stillPending = await Promise.race([
    flow.then(
      () => "resolved",
      () => "rejected"
    ),
    new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),
  ]);
  assert.equal(stillPending, "pending");

  const success = await fetch(`${redirectUri}/?code=ok&state=${getState()}`, {
    redirect: "manual",
  });
  assert.equal(success.status, 302);
  assert.deepEqual(await flow, { code: "ok" });
});

test("a provider error query still fails the flow immediately", async () => {
  const { flow, getRedirectUri } = startFlow();
  const redirectUri = await waitForListen(getRedirectUri);
  const rejected = assert.rejects(flow, /OAuth error: access_denied/);

  const response = await fetch(`${redirectUri}/?error=access_denied`, {
    redirect: "manual",
  });
  assert.equal(response.status, 302);
  await rejected;
});

test("a late state mismatch cannot reject a valid callback already in progress", async () => {
  const { flow, getRedirectUri, getState, callbackStarted, releaseHandleCallback } =
    startBlockedFlow();
  const redirectUri = await waitForListen(getRedirectUri);
  const flowOutcome = flow.then(
    () => "resolved",
    (error) => `rejected: ${error.message}`
  );

  const validResponsePromise = fetch(`${redirectUri}/?code=ok&state=${getState()}`, {
    redirect: "manual",
  });
  await callbackStarted;

  let mismatchResponse;
  let outcomeBeforeRelease;
  try {
    mismatchResponse = await fetch(`${redirectUri}/?code=stale&state=wrong`, {
      redirect: "manual",
    });
    outcomeBeforeRelease = await Promise.race([
      flowOutcome,
      new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),
    ]);
  } finally {
    releaseHandleCallback();
  }

  const validResponse = await validResponsePromise;
  assert.equal(mismatchResponse.status, 400);
  assert.equal(outcomeBeforeRelease, "pending");
  assert.equal(validResponse.status, 302);
  assert.equal(await flowOutcome, "resolved");
});

test("a late malformed request cannot reject a valid callback already in progress", async () => {
  const { flow, getRedirectUri, getState, callbackStarted, releaseHandleCallback } =
    startBlockedFlow();
  const redirectUri = await waitForListen(getRedirectUri);
  const flowOutcome = flow.then(
    () => "resolved",
    (error) => `rejected: ${error.message}`
  );

  const validResponsePromise = fetch(`${redirectUri}/?code=ok&state=${getState()}`, {
    redirect: "manual",
  });
  await callbackStarted;

  let malformedStatus;
  let outcomeBeforeRelease;
  try {
    malformedStatus = await requestPath(redirectUri, "//[");
    outcomeBeforeRelease = await Promise.race([
      flowOutcome,
      new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),
    ]);
  } finally {
    releaseHandleCallback();
  }

  const validResponse = await validResponsePromise;
  assert.equal(malformedStatus, 400);
  assert.equal(outcomeBeforeRelease, "pending");
  assert.equal(validResponse.status, 302);
  assert.equal(await flowOutcome, "resolved");
});

test("a second valid callback cannot start another token exchange", async () => {
  const {
    flow,
    getRedirectUri,
    getState,
    callbackStarted,
    getCallbackCount,
    releaseHandleCallback,
  } = startBlockedFlow();
  const redirectUri = await waitForListen(getRedirectUri);
  const flowOutcome = flow.then(
    (result) => ({ status: "resolved", result }),
    (error) => ({ status: "rejected", error: error.message })
  );

  const firstResponsePromise = fetch(`${redirectUri}/?code=first&state=${getState()}`, {
    redirect: "manual",
  });
  await callbackStarted;

  let duplicateResponse;
  let outcomeBeforeRelease;
  try {
    duplicateResponse = await fetch(`${redirectUri}/?code=duplicate&state=${getState()}`, {
      redirect: "manual",
    });
    outcomeBeforeRelease = await Promise.race([
      flowOutcome,
      new Promise((resolve) => setTimeout(() => resolve("pending"), 200)),
    ]);
  } finally {
    releaseHandleCallback();
  }

  const firstResponse = await firstResponsePromise;
  assert.equal(duplicateResponse.status, 400);
  assert.equal(outcomeBeforeRelease, "pending");
  assert.equal(getCallbackCount(), 1);
  assert.equal(firstResponse.status, 302);
  assert.deepEqual(await flowOutcome, {
    status: "resolved",
    result: { code: "first" },
  });
});

test("an accepted callback cannot run after a malformed request rejects the flow", async () => {
  let callbackCount = 0;
  const { flow, server, getRedirectUri, getState } = startFlow(async () => {
    callbackCount += 1;
    return { ok: true };
  });
  const redirectUri = await waitForListen(getRedirectUri);
  const parkedRequest = await parkPartialRequest(redirectUri, server);
  const rejected = assert.rejects(flow, /Invalid URL/);

  try {
    assert.equal(await requestPath(redirectUri, "//["), 302);
    await rejected;

    const lateStatus = await parkedRequest.complete(`?code=late&state=${getState()}`);
    assert.equal(lateStatus, 400);
    assert.equal(callbackCount, 0);
  } finally {
    parkedRequest.destroy();
  }
});

test("an accepted callback cannot run after the flow times out", async () => {
  let callbackCount = 0;
  const { flow, server, getRedirectUri, getState, triggerTimeout } = startFlowWithControlledTimeout(
    async () => {
      callbackCount += 1;
      return { ok: true };
    }
  );
  const redirectUri = await waitForListen(getRedirectUri);
  const parkedRequest = await parkPartialRequest(redirectUri, server);
  const rejected = assert.rejects(flow, /OAuth flow timed out/);

  try {
    triggerTimeout();
    await rejected;

    const lateStatus = await parkedRequest.complete(`?code=late&state=${getState()}`);
    assert.equal(lateStatus, 400);
    assert.equal(callbackCount, 0);
  } finally {
    parkedRequest.destroy();
  }
});

function freePort() {
  return new Promise((resolve, reject) => {
    const probe = net.createServer();
    probe.once("error", reject);
    probe.listen(0, "127.0.0.1", () => {
      const { port } = probe.address();
      probe.close(() => resolve(port));
    });
  });
}

function getLocal(url) {
  return new Promise((resolve, reject) => {
    http
      .get(url, (res) => {
        let body = "";
        res.setEncoding("utf8");
        res.on("data", (chunk) => {
          body += chunk;
        });
        res.on("end", () => resolve({ status: res.statusCode, headers: res.headers, body }));
      })
      .on("error", reject);
  });
}

async function until(read) {
  for (let attempt = 0; attempt < 200; attempt += 1) {
    const value = read();
    if (value) return value;
    await new Promise((resolve) => setTimeout(resolve, 5));
  }
  throw new Error("timed out waiting");
}

test("a fixed port, redirect host and path shape the redirect uri both times", async () => {
  const port = await freePort();
  const started = startFlow(async (code, redirectUri) => ({ code, redirectUri }), {
    redirectHost: "localhost",
    ports: [port],
    callbackPath: "/slack/callback",
  });
  const redirectUri = await until(started.getRedirectUri);
  assert.equal(redirectUri, `http://localhost:${port}/slack/callback`);

  await getLocal(`http://127.0.0.1:${port}/slack/callback?code=c1&state=${started.getState()}`);

  assert.deepEqual(await started.flow, {
    code: "c1",
    redirectUri: `http://localhost:${port}/slack/callback`,
  });
});

test("a busy fixed port falls through to the next with one browser launch; all busy rejects ports_busy", async () => {
  const blocker = net.createServer();
  await new Promise((resolve) => blocker.listen(0, "127.0.0.1", resolve));
  const busy = blocker.address().port;
  const free = await freePort();
  try {
    const started = startFlow(async (code) => ({ code }), { ports: [busy, free] });
    assert.equal(await until(started.getRedirectUri), `http://127.0.0.1:${free}`);
    await getLocal(`http://127.0.0.1:${free}/?code=c2&state=${started.getState()}`);
    assert.deepEqual(await started.flow, { code: "c2" });
    assert.equal(started.getAuthUrlCalls(), 1, "exactly one browser launch");

    const allBusy = startFlow(async () => ({}), { ports: [busy] });
    await assert.rejects(allBusy.flow, (error) => error.code === "ports_busy");
    assert.equal(allBusy.getAuthUrlCalls(), 0);
  } finally {
    blocker.close();
  }
});

test("a local result page replaces the hosted desktop-callback redirect", async () => {
  const started = startFlow(async () => ({ ok: true }), {
    renderResultPage: ({ ok }) => `<p>${ok ? "connected" : "failed"}</p>`,
  });
  const redirectUri = await until(started.getRedirectUri);

  const response = await getLocal(`${redirectUri}/?code=c3&state=${started.getState()}`);

  assert.equal(response.status, 200);
  assert.equal(response.headers.location, undefined);
  assert.equal(response.body, "<p>connected</p>");
  await started.flow;
});

test("a denied consent rejects with oauth_denied and shows the failure page", async () => {
  const started = startFlow(async () => ({}), {
    renderResultPage: ({ ok }) => (ok ? "yes" : "no"),
  });
  const redirectUri = await until(started.getRedirectUri);
  const outcome = started.flow.catch((error) => error);

  const response = await getLocal(
    `${redirectUri}/?error=access_denied&state=${started.getState()}`
  );

  assert.equal(response.body, "no");
  const error = await outcome;
  assert.equal(error.code, "oauth_denied");
  assert.equal(error.providerError, "access_denied");
});

const RELAY = "https://openwhispr.com/auth/slack/callback";

test("behind a relay, the public redirect URI goes to the provider and the exchange, and state carries the port", async () => {
  const started = startFlow(async (code, redirectUri) => ({ code, redirectUri }), {
    publicRedirectUri: RELAY,
    callbackPath: "/slack/callback",
  });
  assert.equal(await until(started.getRedirectUri), RELAY);
  const port = started.server.address().port;
  assert.match(started.getState(), new RegExp(`^v1\\.${port}\\.[0-9a-f]{64}$`));

  // What the relay does with Slack's redirect.
  await getLocal(`http://127.0.0.1:${port}/slack/callback?code=c4&state=${started.getState()}`);

  assert.deepEqual(await started.flow, { code: "c4", redirectUri: RELAY });
  assert.equal(started.getAuthUrlCalls(), 1);
});

test("behind a relay, the right port with another nonce is a state mismatch", async () => {
  const started = startFlow(async () => ({ ok: true }), { publicRedirectUri: RELAY });
  await until(started.getRedirectUri);
  const port = started.server.address().port;
  const outcome = started.flow.catch((error) => error);

  await getLocal(`http://127.0.0.1:${port}/?code=c5&state=v1.${port}.${"0".repeat(64)}`);

  assert.equal((await outcome).code, "oauth_state_mismatch");
});

test("without a relay, the state stays a bare nonce", async () => {
  const started = startFlow(async (code) => ({ code }));
  await until(started.getRedirectUri);
  assert.match(started.getState(), /^[0-9a-f]{64}$/);

  await getLocal(`${started.getRedirectUri()}/?code=c6&state=${started.getState()}`);

  assert.deepEqual(await started.flow, { code: "c6" });
});

test("timeoutMs bounds how long the flow waits", { timeout: 5000 }, async () => {
  const started = startFlow(async () => ({}), { timeoutMs: 30 });
  await assert.rejects(started.flow, (error) => error.code === "oauth_timeout");
});

test("an abort closes the server and rejects oauth_cancelled", async () => {
  const controller = new AbortController();
  let callbackCount = 0;
  const started = startFlow(
    async () => {
      callbackCount += 1;
      return {};
    },
    { signal: controller.signal }
  );
  const redirectUri = await until(started.getRedirectUri);
  const outcome = started.flow.catch((error) => error);

  controller.abort();

  assert.equal((await outcome).code, "oauth_cancelled");
  assert.equal(started.server.listening, false);
  await assert.rejects(getLocal(`${redirectUri}/?code=late&state=${started.getState()}`));
  assert.equal(callbackCount, 0);
});

test("a flow whose signal is already aborted never opens the browser", async () => {
  const controller = new AbortController();
  controller.abort();
  const started = startFlow(async () => ({}), { signal: controller.signal });

  await assert.rejects(started.flow, (error) => error.code === "oauth_cancelled");
  await new Promise((resolve) => setTimeout(resolve, 20));
  assert.equal(started.getAuthUrlCalls(), 0);
});

test("an abort after the provider answered lets the exchange finish", async () => {
  const controller = new AbortController();
  let release;
  let markStarted;
  const exchangeStarted = new Promise((resolve) => {
    markStarted = resolve;
  });
  const started = startFlow(
    async (code) => {
      markStarted();
      await new Promise((resolve) => {
        release = resolve;
      });
      return { code };
    },
    { signal: controller.signal }
  );
  const redirectUri = await until(started.getRedirectUri);

  const response = getLocal(`${redirectUri}/?code=c9&state=${started.getState()}`);
  await exchangeStarted;
  controller.abort();
  release();

  // The caller decides what to do with a login it no longer wants; the flow
  // never drops one the provider already issued.
  assert.deepEqual(await started.flow, { code: "c9" });
  assert.equal((await response).status, 302);
});

async function stillWaiting(flow) {
  return Promise.race([
    flow.then(
      () => "resolved",
      () => "rejected"
    ),
    new Promise((resolve) => setTimeout(() => resolve("pending"), 100)),
  ]);
}

test("behind a relay, an error without this flow's state is a stray request, not a denial", async () => {
  const started = startFlow(async (code) => ({ code }), { publicRedirectUri: RELAY });
  await until(started.getRedirectUri);
  const port = started.server.address().port;

  const bare = await getLocal(`http://127.0.0.1:${port}/anything?error=access_denied`);
  const otherState = await getLocal(
    `http://127.0.0.1:${port}/?error=access_denied&state=v1.${port}.${"0".repeat(64)}`
  );

  assert.equal(bare.status, 400);
  assert.equal(otherState.status, 400);
  assert.equal(await stillWaiting(started.flow), "pending");
  await getLocal(`http://127.0.0.1:${port}/?code=c7&state=${started.getState()}`);
  assert.deepEqual(await started.flow, { code: "c7" });
});

test("behind a relay, an error with this flow's state still denies", async () => {
  const started = startFlow(async () => ({}), { publicRedirectUri: RELAY });
  await until(started.getRedirectUri);
  const port = started.server.address().port;
  const outcome = started.flow.catch((error) => error);

  await getLocal(`http://127.0.0.1:${port}/?error=access_denied&state=${started.getState()}`);

  assert.equal((await outcome).code, "oauth_denied");
});

test("with a callback path, only that path is a callback", async () => {
  const started = startFlow(async (code) => ({ code }), {
    publicRedirectUri: RELAY,
    callbackPath: "/slack/callback",
  });
  await until(started.getRedirectUri);
  const port = started.server.address().port;
  const state = started.getState();

  const wrongPathCode = await getLocal(`http://127.0.0.1:${port}/other?code=stray&state=${state}`);
  const wrongPathError = await getLocal(
    `http://127.0.0.1:${port}/other?error=access_denied&state=${state}`
  );

  assert.equal(wrongPathCode.status, 400);
  assert.equal(wrongPathError.status, 400);
  assert.equal(await stillWaiting(started.flow), "pending");
  await getLocal(`http://127.0.0.1:${port}/slack/callback?code=c8&state=${state}`);
  assert.deepEqual(await started.flow, { code: "c8" });
});