Share cloud task API transport

Generated-By: PostHog Code
Task-Id: 40c57a59-b4e1-4760-8e56-ecd03e9c2f0f

Author: richardsolomou

apps/mobile/package.json

@@ -27,6 +27,8 @@
     "@expo/ui": "0.2.0-beta.9",
     "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@posthog/api-client": "workspace:*",
+    "@posthog/core": "workspace:*",
     "@posthog/shared": "workspace:*",
     "@react-native-async-storage/async-storage": "^2.2.0",
     "@react-native-community/netinfo": "^12.0.1",

apps/mobile/src/lib/analytics.ts

@@ -1,5 +1,4 @@
-import type { PostHogEventProperties } from "@posthog/core";
-import { usePostHog } from "posthog-react-native";
+import { type PostHog, usePostHog } from "posthog-react-native";
 import { useEffect, useMemo } from "react";
 
 /**
@@ -199,6 +198,8 @@ export interface Analytics {
   ): void;
 }
 
+type PostHogCaptureProperties = Parameters<PostHog["capture"]>[1];
+
 // Client discriminator stamped on inbox events so the shared PostHog project
 // can be sliced by surface (desktop sends "code", the web frontend sends
 // "cloud"). Mirrors packages/ui/src/shell/posthogAnalyticsImpl.ts.
@@ -221,12 +222,9 @@ export function useAnalytics(): Analytics {
         const enriched = INBOX_ANALYTICS_EVENT_NAMES.has(eventName)
           ? { inbox_client: INBOX_CLIENT, ...properties }
           : properties;
-        // Our typed property interfaces don't carry an index signature; cast
-        // to the wider PostHog event-properties shape without losing the
-        // narrower call-site type-check.
         posthog?.capture(
           eventName,
-          enriched as unknown as PostHogEventProperties,
+          enriched as unknown as PostHogCaptureProperties,
         );
       },
     }),

apps/mobile/src/lib/api.ts

@@ -3,9 +3,20 @@ import Constants from "expo-constants";
 import { useAuthStore } from "@/features/auth";
 import { logger } from "@/lib/logger";
 
+export class HttpError extends Error {
+  constructor(
+    readonly status: number,
+    readonly statusText: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = "HttpError";
+  }
+}
+
 // Derive the init shape directly from expo/fetch so we don't import from
 // expo's internal build output (which can move between versions).
-type FetchInit = NonNullable<Parameters<typeof fetch>[1]>;
+export type FetchInit = NonNullable<Parameters<typeof fetch>[1]>;
 
 const log = logger.scope("api");
 
@@ -66,7 +77,7 @@ export function createTimeoutSignal(ms: number): AbortSignal {
 // pending refresh across all callers and reset it once it settles.
 let pendingRefresh: Promise<void> | null = null;
 
-async function refreshAccessTokenOnce(): Promise<void> {
+export async function refreshAccessTokenOnce(): Promise<void> {
   if (pendingRefresh) return pendingRefresh;
   const promise = useAuthStore
     .getState()

apps/mobile/src/lib/posthogApiClient.test.ts

@@ -0,0 +1,190 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  authState: {
+    cloudRegion: "us" as string | null,
+    getCloudUrlFromRegion: vi.fn(() => "https://us.posthog.com"),
+    oauthAccessToken: "access-token" as string | null,
+    projectId: 123 as number | null,
+    refreshAccessToken: vi.fn(async () => {}),
+  },
+  expoApplication: {
+    nativeApplicationVersion: "1.2.3" as string | null,
+  },
+  expoConstants: {
+    expoConfig: { version: "9.9.9" } as { version?: string } | null,
+  },
+  expoFetch: vi.fn(),
+  instances: [] as Array<{
+    apiHost: string;
+    getAccessToken: () => Promise<string>;
+    refreshAccessToken: () => Promise<string>;
+    teamId: number | undefined;
+    options: Record<string, unknown>;
+    setTeamId: ReturnType<typeof vi.fn>;
+  }>,
+}));
+
+vi.mock("@posthog/api-client/posthog-client", () => ({
+  PostHogAPIClient: class {
+    setTeamId = vi.fn();
+
+    constructor(
+      apiHost: string,
+      getAccessToken: () => Promise<string>,
+      refreshAccessToken: () => Promise<string>,
+      teamId: number | undefined,
+      options: Record<string, unknown>,
+    ) {
+      mocks.instances.push({
+        apiHost,
+        getAccessToken,
+        refreshAccessToken,
+        teamId,
+        options,
+        setTeamId: this.setTeamId,
+      });
+    }
+  },
+}));
+
+vi.mock("expo-application", () => ({
+  get nativeApplicationVersion() {
+    return mocks.expoApplication.nativeApplicationVersion;
+  },
+}));
+
+vi.mock("expo-constants", () => ({
+  default: {
+    get expoConfig() {
+      return mocks.expoConstants.expoConfig;
+    },
+  },
+}));
+
+vi.mock("expo/fetch", () => ({ fetch: mocks.expoFetch }));
+
+vi.mock("@/features/auth", () => ({
+  useAuthStore: {
+    getState: () => mocks.authState,
+  },
+}));
+
+beforeEach(() => {
+  vi.resetModules();
+  vi.clearAllMocks();
+  mocks.instances.length = 0;
+  mocks.authState.cloudRegion = "us";
+  mocks.authState.oauthAccessToken = "access-token";
+  mocks.authState.projectId = 123;
+  mocks.authState.getCloudUrlFromRegion.mockReturnValue(
+    "https://us.posthog.com",
+  );
+  mocks.authState.refreshAccessToken.mockImplementation(async () => {});
+  mocks.expoApplication.nativeApplicationVersion = "1.2.3";
+  mocks.expoConstants.expoConfig = { version: "9.9.9" };
+});
+
+describe("createPostHogApiClient", () => {
+  it("configures the shared client for the mobile host", async () => {
+    const { createPostHogApiClient } = await import("./posthogApiClient");
+
+    createPostHogApiClient();
+
+    expect(mocks.instances).toHaveLength(1);
+    expect(mocks.instances[0]).toMatchObject({
+      apiHost: "https://us.posthog.com",
+      teamId: 123,
+      options: {
+        appVersion: "1.2.3",
+        fetch: mocks.expoFetch,
+        githubConnectFrom: "posthog_mobile",
+        userAgent: "posthog/mobile.hog.dev; version: 1.2.3",
+      },
+    });
+  });
+
+  it("falls back to the Expo config version", async () => {
+    mocks.expoApplication.nativeApplicationVersion = null;
+    mocks.expoConstants.expoConfig = { version: "4.5.6" };
+    const { createPostHogApiClient } = await import("./posthogApiClient");
+
+    createPostHogApiClient();
+
+    expect(mocks.instances[0]?.options).toMatchObject({
+      appVersion: "4.5.6",
+      userAgent: "posthog/mobile.hog.dev; version: 4.5.6",
+    });
+  });
+
+  it("returns the refreshed token from the current auth store state", async () => {
+    mocks.authState.refreshAccessToken.mockImplementation(async () => {
+      mocks.authState.oauthAccessToken = "refreshed-token";
+    });
+    const { createPostHogApiClient } = await import("./posthogApiClient");
+    createPostHogApiClient();
+
+    await expect(mocks.instances[0]?.refreshAccessToken()).resolves.toBe(
+      "refreshed-token",
+    );
+    expect(mocks.authState.refreshAccessToken).toHaveBeenCalledOnce();
+  });
+
+  it("shares one refresh across concurrent client retries", async () => {
+    let resolveRefresh: (() => void) | undefined;
+    mocks.authState.refreshAccessToken.mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveRefresh = () => {
+            mocks.authState.oauthAccessToken = "refreshed-token";
+            resolve();
+          };
+        }),
+    );
+    const { createPostHogApiClient } = await import("./posthogApiClient");
+    createPostHogApiClient();
+
+    const refreshes = [
+      mocks.instances[0]?.refreshAccessToken(),
+      mocks.instances[0]?.refreshAccessToken(),
+    ];
+    expect(mocks.authState.refreshAccessToken).toHaveBeenCalledOnce();
+    resolveRefresh?.();
+
+    await expect(Promise.all(refreshes)).resolves.toEqual([
+      "refreshed-token",
+      "refreshed-token",
+    ]);
+  });
+});
+
+describe("getPostHogApiClient", () => {
+  it("reuses the regional client and updates its project", async () => {
+    const { getPostHogApiClient } = await import("./posthogApiClient");
+
+    const first = getPostHogApiClient();
+    mocks.authState.projectId = 456;
+    const second = getPostHogApiClient();
+
+    expect(second).toBe(first);
+    expect(mocks.instances).toHaveLength(1);
+    expect(mocks.instances[0]?.setTeamId).toHaveBeenCalledWith(456);
+  });
+
+  it("creates a new client when the cloud region changes", async () => {
+    const { getPostHogApiClient } = await import("./posthogApiClient");
+
+    const first = getPostHogApiClient();
+    mocks.authState.cloudRegion = "eu";
+    mocks.authState.getCloudUrlFromRegion.mockReturnValue(
+      "https://eu.posthog.com",
+    );
+    const second = getPostHogApiClient();
+
+    expect(second).not.toBe(first);
+    expect(mocks.instances.map(({ apiHost }) => apiHost)).toEqual([
+      "https://us.posthog.com",
+      "https://eu.posthog.com",
+    ]);
+  });
+});

apps/mobile/src/lib/posthogApiClient.ts

@@ -0,0 +1,84 @@
+import type { FetchImplementation } from "@posthog/api-client/fetcher";
+import { PostHogAPIClient } from "@posthog/api-client/posthog-client";
+import { fetch } from "expo/fetch";
+import * as Application from "expo-application";
+import Constants from "expo-constants";
+import { useAuthStore } from "@/features/auth";
+import { refreshAccessTokenOnce } from "@/lib/api";
+
+const MOBILE_GITHUB_CONNECT_FROM = "posthog_mobile";
+
+let posthogApiClient: PostHogAPIClient | null = null;
+let posthogApiHost: string | null = null;
+
+function getAppVersion(): string {
+  return (
+    Application.nativeApplicationVersion ??
+    Constants.expoConfig?.version ??
+    "unknown"
+  );
+}
+
+function getAuthenticatedContext(): {
+  apiHost: string;
+  projectId: number;
+} {
+  const { cloudRegion, getCloudUrlFromRegion, projectId } =
+    useAuthStore.getState();
+
+  if (!cloudRegion) {
+    throw new Error("No cloud region set");
+  }
+  if (!projectId) {
+    throw new Error("No project ID set");
+  }
+
+  return {
+    apiHost: getCloudUrlFromRegion(cloudRegion),
+    projectId,
+  };
+}
+
+async function getAccessToken(): Promise<string> {
+  const { oauthAccessToken } = useAuthStore.getState();
+  if (!oauthAccessToken) {
+    throw new Error("Not authenticated");
+  }
+  return oauthAccessToken;
+}
+
+async function refreshAccessToken(): Promise<string> {
+  await refreshAccessTokenOnce();
+  return getAccessToken();
+}
+
+export function createPostHogApiClient(): PostHogAPIClient {
+  const { apiHost, projectId } = getAuthenticatedContext();
+  const appVersion = getAppVersion();
+
+  return new PostHogAPIClient(
+    apiHost,
+    getAccessToken,
+    refreshAccessToken,
+    projectId,
+    {
+      appVersion,
+      fetch: fetch as FetchImplementation,
+      githubConnectFrom: MOBILE_GITHUB_CONNECT_FROM,
+      userAgent: `posthog/mobile.hog.dev; version: ${appVersion}`,
+    },
+  );
+}
+
+export function getPostHogApiClient(): PostHogAPIClient {
+  const { apiHost, projectId } = getAuthenticatedContext();
+
+  if (!posthogApiClient || posthogApiHost !== apiHost) {
+    posthogApiClient = createPostHogApiClient();
+    posthogApiHost = apiHost;
+  } else {
+    posthogApiClient.setTeamId(projectId);
+  }
+
+  return posthogApiClient;
+}

packages/api-client/package.json

@@ -25,7 +25,6 @@
     "src/**/*"
   ],
   "dependencies": {
-    "@posthog/agent": "workspace:*",
     "@posthog/shared": "workspace:*"
   }
 }

packages/api-client/src/fetcher.test.ts

@@ -53,6 +53,45 @@ describe("buildApiFetcher", () => {
     expect(mockFetch.mock.calls[0][1].headers.get("Authorization")).toBe(
       "Bearer my-token",
     );
+    expect(mockFetch.mock.calls[0][1].headers.get("User-Agent")).toBe(
+      "posthog/desktop.hog.dev; version: test",
+    );
+  });
+
+  it("uses an injected fetch implementation and custom user agent", async () => {
+    const injectedFetch = vi.fn().mockResolvedValueOnce(ok());
+    const fetcher = buildApiFetcher({
+      getAccessToken: vi.fn().mockResolvedValue("token"),
+      refreshAccessToken: vi.fn().mockResolvedValue("new-token"),
+      appVersion: "1.2.3",
+      fetch: injectedFetch,
+      userAgent: "posthog/mobile; version: 1.2.3",
+    });
+
+    await fetcher.fetch(mockInput);
+
+    expect(injectedFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(injectedFetch.mock.calls[0][1].headers.get("User-Agent")).toBe(
+      "posthog/mobile; version: 1.2.3",
+    );
+  });
+
+  it("omits the user agent when explicitly disabled", async () => {
+    const injectedFetch = vi.fn().mockResolvedValueOnce(ok());
+    const fetcher = buildApiFetcher({
+      getAccessToken: vi.fn().mockResolvedValue("token"),
+      refreshAccessToken: vi.fn().mockResolvedValue("new-token"),
+      appVersion: "1.2.3",
+      fetch: injectedFetch,
+      userAgent: null,
+    });
+
+    await fetcher.fetch(mockInput);
+
+    expect(injectedFetch.mock.calls[0][1].headers.has("User-Agent")).toBe(
+      false,
+    );
   });
 
   it("retries once with a freshly fetched token on 401", async () => {