@limrun/ui 0.14.0-rc.2 → 0.14.0-rc.3

package/src/core/device-install/apple/client.ts

@@ -99,12 +99,7 @@ export async function startBrowserOwnedAppleIDLogin({
       finishTwoFactor: async (code) => {
         const response =
           twoFactorMethod.type === 'phone' ?
-            await proxyPhoneTwoFactorCode(
-              relay,
-              twoFactorMethod.phoneNumberId,
-              code,
-              twoFactorMethod.mode,
-            )
+            await proxyPhoneTwoFactorCode(relay, twoFactorMethod.phoneNumberId, code, twoFactorMethod.mode)
           : await proxyTwoFactorCode(relay, code);
         if (response.status < 200 || response.status >= 300) {
           throw new Error(

package/src/core/device-install/apple/relay.ts

@@ -104,10 +104,7 @@ export async function openAppleRelayWebSocket(apiUrl: string, token?: string, or
   return client;
 }
 
-export async function proxySrpInit(
-  relay: AppleRelayWebSocketClient,
-  payload: AppleSRPInitRequest,
-) {
+export async function proxySrpInit(relay: AppleRelayWebSocketClient, payload: AppleSRPInitRequest) {
   return relay.request<AppleSRPInitResponse>('srpInit', payload);
 }
 

package/src/core/device-install/operations/operations.ts

@@ -46,7 +46,13 @@ export async function requestUSBAccess({ log }: RequestUSBAccessOptions) {
   return target;
 }
 
-export async function startPairingRelay({ registryApiUrl, token, organizationId, log, target }: StartPairingRelayOptions) {
+export async function startPairingRelay({
+  registryApiUrl,
+  token,
+  organizationId,
+  log,
+  target,
+}: StartPairingRelayOptions) {
   const deviceRelayUrl = deviceRelayWebSocketUrl(registryApiUrl, token, organizationId);
   let relay: RelayClient | undefined;
   try {

package/src/core/play-publish/google.ts

@@ -0,0 +1,104 @@
+const GSI_SRC = 'https://accounts.google.com/gsi/client';
+
+export const ANDROID_PUBLISHER_SCOPE = 'https://www.googleapis.com/auth/androidpublisher';
+
+type TokenResponse = { access_token?: string; error?: string; error_description?: string };
+type TokenClient = { requestAccessToken: () => void };
+type GoogleOAuth2 = {
+  initTokenClient: (config: {
+    client_id: string;
+    scope: string;
+    callback: (response: TokenResponse) => void;
+    error_callback?: (error: { type?: string; message?: string }) => void;
+  }) => TokenClient;
+};
+
+function googleOAuth2(): GoogleOAuth2 | undefined {
+  return (globalThis as { google?: { accounts?: { oauth2?: GoogleOAuth2 } } }).google?.accounts?.oauth2;
+}
+
+let gsiLoad: Promise<void> | undefined;
+
+export function loadGoogleIdentityServices(): Promise<void> {
+  if (googleOAuth2()) {
+    return Promise.resolve();
+  }
+  if (typeof document === 'undefined') {
+    return Promise.reject(new Error('Google sign-in requires a browser environment.'));
+  }
+  if (!gsiLoad) {
+    gsiLoad = new Promise<void>((resolve, reject) => {
+      const script = document.createElement('script');
+      script.src = GSI_SRC;
+      script.async = true;
+      script.addEventListener(
+        'load',
+        () => {
+          if (googleOAuth2()) {
+            resolve();
+          } else {
+            reject(new Error('Google sign-in script loaded without the OAuth client.'));
+          }
+        },
+        { once: true },
+      );
+      script.addEventListener(
+        'error',
+        () => {
+          script.remove();
+          reject(new Error('Failed to load the Google sign-in script.'));
+        },
+        { once: true },
+      );
+      document.head.appendChild(script);
+    });
+    // A failed load (offline, blocked CDN) must not poison retries.
+    gsiLoad.catch(() => {
+      gsiLoad = undefined;
+    });
+  }
+  return gsiLoad;
+}
+
+export type RequestGoogleAccessTokenInput = {
+  clientId: string;
+  scope?: string;
+};
+
+/**
+ * Opens the Google consent popup and resolves with a short-lived OAuth
+ * access token. Call from a user gesture so popup blockers allow it, and
+ * call loadGoogleIdentityServices beforehand (e.g. when the surrounding
+ * dialog opens) to keep this call synchronous with the click.
+ */
+export async function requestGoogleAccessToken({
+  clientId,
+  scope = ANDROID_PUBLISHER_SCOPE,
+}: RequestGoogleAccessTokenInput): Promise<string> {
+  await loadGoogleIdentityServices();
+  return new Promise<string>((resolve, reject) => {
+    const client = googleOAuth2()!.initTokenClient({
+      client_id: clientId,
+      scope,
+      callback: (response) => {
+        if (response.error) {
+          reject(new Error(response.error_description || response.error));
+          return;
+        }
+        if (!response.access_token) {
+          reject(new Error('Google returned no access token.'));
+          return;
+        }
+        resolve(response.access_token);
+      },
+      error_callback: (error) => {
+        const fallback =
+          error?.type === 'popup_failed_to_open' ?
+            'Google sign-in popup was blocked by the browser.'
+          : 'Google sign-in was cancelled.';
+        reject(new Error(error?.message || fallback));
+      },
+    });
+    client.requestAccessToken();
+  });
+}

package/src/core/play-publish/publish.test.ts

@@ -0,0 +1,68 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { PlaystorePublishError, publishToPlaystore } from './publish';
+
+function mockFetch(status: number, body: string) {
+  const fetchMock = vi.fn(async () => new Response(body, { status }));
+  vi.stubGlobal('fetch', fetchMock);
+  return fetchMock;
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('publishToPlaystore', () => {
+  it('posts to the publish path with auth and org headers and returns the versionCode', async () => {
+    const fetchMock = mockFetch(200, JSON.stringify({ versionCode: 42 }));
+    const result = await publishToPlaystore({
+      registryApiUrl: 'https://registry-staging.limrun.dev',
+      token: 'limrun-token',
+      organizationId: 'org_x',
+      accessToken: 'google-token',
+      packageName: 'com.example.app',
+      assetName: 'app-release.aab',
+    });
+    expect(result.versionCode).toBe(42);
+    const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
+    expect(url).toBe('https://registry-staging.limrun.dev/android/playstore/publish');
+    const headers = init.headers as Record<string, string>;
+    expect(headers.Authorization).toBe('Bearer limrun-token');
+    expect(headers['X-Limrun-Organization']).toBe('org_x');
+    const body = JSON.parse(init.body as string) as Record<string, unknown>;
+    expect(body).toEqual({
+      accessToken: 'google-token',
+      packageName: 'com.example.app',
+      assetName: 'app-release.aab',
+    });
+  });
+
+  it('surfaces the registry error message and code', async () => {
+    mockFetch(
+      409,
+      JSON.stringify({ message: 'Version code 2 has already been used', code: 'versionCodeExists' }),
+    );
+    const error = await publishToPlaystore({
+      registryApiUrl: 'https://registry-staging.limrun.dev',
+      accessToken: 'google-token',
+      packageName: 'com.example.app',
+      assetName: 'app-release.aab',
+    }).catch((caught: unknown) => caught);
+    expect(error).toBeInstanceOf(PlaystorePublishError);
+    const publishError = error as PlaystorePublishError;
+    expect(publishError.code).toBe('versionCodeExists');
+    expect(publishError.status).toBe(409);
+    expect(publishError.message).toContain('already been used');
+  });
+
+  it('handles non-JSON error bodies', async () => {
+    mockFetch(502, '<html>bad gateway</html>');
+    const error = await publishToPlaystore({
+      registryApiUrl: 'https://registry-staging.limrun.dev',
+      accessToken: 'google-token',
+      packageName: 'com.example.app',
+      assetId: 'asset_1',
+    }).catch((caught: unknown) => caught);
+    expect(error).toBeInstanceOf(PlaystorePublishError);
+    expect((error as PlaystorePublishError).message).toContain('HTTP 502');
+  });
+});

package/src/core/play-publish/publish.ts

@@ -0,0 +1,89 @@
+export type PlaystorePublishInput = {
+  registryApiUrl: string;
+  /** Limrun API token authenticating the registry call. */
+  token?: string;
+  /** Organization tid; required when it differs from the token's default organization. */
+  organizationId?: string;
+  /** Google OAuth access token with the androidpublisher scope. Sent per request, never stored. */
+  accessToken: string;
+  packageName: string;
+  assetId?: string;
+  assetName?: string;
+  /** Play track ID, defaults to internal on the server. */
+  track?: string;
+  /** Required by the server when track is production. */
+  releaseStatus?: 'draft' | 'completed';
+};
+
+export type PlaystorePublishResult = {
+  versionCode: number;
+};
+
+/**
+ * Registry publish failure. `code` carries the registry's machine-readable
+ * error code when available: invalidRequest, assetNotFound, internal, busy,
+ * listingNotFound, permissionDenied, versionCodeExists, uploadKeyMismatch
+ * or unknown; the set grows additively.
+ */
+export class PlaystorePublishError extends Error {
+  readonly code?: string;
+  readonly status?: number;
+
+  constructor(message: string, options: { code?: string; status?: number } = {}) {
+    super(message);
+    this.name = 'PlaystorePublishError';
+    this.code = options.code;
+    this.status = options.status;
+  }
+}
+
+export async function publishToPlaystore(input: PlaystorePublishInput): Promise<PlaystorePublishResult> {
+  const { registryApiUrl, token, organizationId, ...body } = input;
+  let url: URL;
+  try {
+    url = new URL(registryApiUrl);
+  } catch {
+    throw new PlaystorePublishError(`Invalid registry URL: ${registryApiUrl}`);
+  }
+  url.pathname = `${url.pathname.replace(/\/$/, '')}/android/playstore/publish`;
+  url.search = '';
+  url.hash = '';
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  if (organizationId) {
+    headers['X-Limrun-Organization'] = organizationId;
+  }
+  let response: Response;
+  try {
+    response = await fetch(url.toString(), {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+  } catch (caught) {
+    throw new PlaystorePublishError(
+      `Cannot reach the registry: ${caught instanceof Error ? caught.message : String(caught)}`,
+    );
+  }
+  const raw = await response.text();
+  let parsed: { versionCode?: number; message?: string; code?: string } | undefined;
+  try {
+    parsed = raw ? (JSON.parse(raw) as typeof parsed) : undefined;
+  } catch {
+    parsed = undefined;
+  }
+  if (!response.ok) {
+    throw new PlaystorePublishError(parsed?.message || `Play publish failed with HTTP ${response.status}`, {
+      code: parsed?.code,
+      status: response.status,
+    });
+  }
+  if (typeof parsed?.versionCode !== 'number') {
+    throw new PlaystorePublishError('Play publish response is missing versionCode.', {
+      status: response.status,
+    });
+  }
+  return { versionCode: parsed.versionCode };
+}

package/src/device-install/demo/demo.tsx

@@ -295,10 +295,7 @@ function App() {
     }
   }
 
-  async function loadAppleResources(
-    teamId = developerTeamId,
-    relay = appleLogin.session?.relay,
-  ) {
+  async function loadAppleResources(teamId = developerTeamId, relay = appleLogin.session?.relay) {
     if (!apiUrl.trim() || !relay || !teamId) return;
     const base = {
       relay,

package/src/device-install/react.ts

@@ -136,33 +136,36 @@ export function useDeviceInstallRelay({
     }
   }, [apiUrl, cleanupDeviceAccess, device, organizationId, token]);
 
-  const startInstallation = useCallback(async (installSource: InstallSource) => {
-    if (!apiUrl || !device || !pairRecord) {
-      throw new Error('Select and pair a USB device before starting installation.');
-    }
-    setBusyAction('install');
-    setError(undefined);
-    try {
-      await cleanupDeviceAccess();
-      relayRef.current = await startDeviceInstall({
-        registryApiUrl: apiUrl,
-        token,
-        organizationId,
-        log: logRef.current,
-        target: device,
-        pairRecord,
-        installSource,
-      });
-      logRef.current('Device install started', 'Installation will continue through the connected iPhone.');
-      return relayRef.current;
-    } catch (caught) {
-      await closeDeviceRelayTarget(device, logRef.current);
-      setError(errorMessage(caught));
-      return undefined;
-    } finally {
-      setBusyAction(undefined);
-    }
-  }, [apiUrl, cleanupDeviceAccess, device, organizationId, pairRecord, token]);
+  const startInstallation = useCallback(
+    async (installSource: InstallSource) => {
+      if (!apiUrl || !device || !pairRecord) {
+        throw new Error('Select and pair a USB device before starting installation.');
+      }
+      setBusyAction('install');
+      setError(undefined);
+      try {
+        await cleanupDeviceAccess();
+        relayRef.current = await startDeviceInstall({
+          registryApiUrl: apiUrl,
+          token,
+          organizationId,
+          log: logRef.current,
+          target: device,
+          pairRecord,
+          installSource,
+        });
+        logRef.current('Device install started', 'Installation will continue through the connected iPhone.');
+        return relayRef.current;
+      } catch (caught) {
+        await closeDeviceRelayTarget(device, logRef.current);
+        setError(errorMessage(caught));
+        return undefined;
+      } finally {
+        setBusyAction(undefined);
+      }
+    },
+    [apiUrl, cleanupDeviceAccess, device, organizationId, pairRecord, token],
+  );
 
   const stopRelay = useCallback(() => {
     void cleanupDeviceAccess();

package/src/play-publish/README.md

@@ -0,0 +1,65 @@
+# @limrun/ui/play-publish
+
+Headless building blocks for publishing an AAB asset from the Limrun
+registry to Google Play, with a browser-owned Google sign-in. No UI ships
+here; embedders render their own buttons and dialogs around the hook,
+same as `device-install`.
+
+The Google access token is minted in the browser via Google Identity
+Services (token model, no client secret) and sent to the registry once
+per publish. Limrun never stores it.
+
+## Requirements
+
+- A Google OAuth **Web application** client ID whose authorized
+  JavaScript origins include your app's origin.
+- The signed-in Google account needs release permission for the target
+  app in Play Console, and the app listing must already exist.
+- The asset must be an AAB signed with the app's Play upload key.
+
+## React
+
+```tsx
+import { usePlaystorePublish } from '@limrun/ui/play-publish/react';
+
+const play = usePlaystorePublish({
+  registryApiUrl: 'https://registry.limrun.com',
+  token: limrunToken,
+  organizationId: organizationTid,
+  googleClientId: GOOGLE_OAUTH_CLIENT_ID,
+});
+
+// On dialog open, warm the sign-in script so the click stays popup-safe:
+play.preloadGoogle();
+
+// Button handlers:
+await play.signInWithGoogle();
+await play.publish({ assetName: 'app-release.aab', packageName: 'com.example.app' });
+
+// Render from state: play.status, play.versionCode, play.error, play.errorCode
+```
+
+`errorCode` values: `invalidRequest`, `assetNotFound`, `internal`, `busy`,
+`listingNotFound`, `permissionDenied`, `versionCodeExists`,
+`uploadKeyMismatch`, `unknown`. The set grows additively.
+
+Google access tokens expire after about an hour. A `permissionDenied`
+error long after sign-in usually means the token expired; offer "Sign in
+with Google" again rather than pointing users at Play Console
+permissions.
+
+## Without React
+
+```ts
+import { requestGoogleAccessToken, publishToPlaystore } from '@limrun/ui/play-publish';
+
+const accessToken = await requestGoogleAccessToken({ clientId: GOOGLE_OAUTH_CLIENT_ID });
+const { versionCode } = await publishToPlaystore({
+  registryApiUrl,
+  token,
+  organizationId,
+  accessToken,
+  assetName: 'app-release.aab',
+  packageName: 'com.example.app',
+});
+```

package/src/play-publish/index.ts

@@ -0,0 +1,12 @@
+export {
+  ANDROID_PUBLISHER_SCOPE,
+  loadGoogleIdentityServices,
+  requestGoogleAccessToken,
+  type RequestGoogleAccessTokenInput,
+} from '../core/play-publish/google';
+export {
+  publishToPlaystore,
+  PlaystorePublishError,
+  type PlaystorePublishInput,
+  type PlaystorePublishResult,
+} from '../core/play-publish/publish';

package/src/play-publish/react.ts

@@ -0,0 +1,168 @@
+import { useCallback, useRef, useState } from 'react';
+import {
+  loadGoogleIdentityServices,
+  PlaystorePublishError,
+  publishToPlaystore,
+  requestGoogleAccessToken,
+  type PlaystorePublishInput,
+  type PlaystorePublishResult,
+} from './index';
+
+export type UsePlaystorePublishOptions = Partial<
+  Pick<PlaystorePublishInput, 'registryApiUrl' | 'token' | 'organizationId'>
+> & {
+  /** Google OAuth Web application client ID used for sign-in. */
+  googleClientId?: string;
+};
+
+export type PlaystorePublishStatus = 'idle' | 'signing-in' | 'ready' | 'publishing' | 'published' | 'error';
+
+export type PlaystorePublishRequest = Omit<
+  PlaystorePublishInput,
+  'registryApiUrl' | 'token' | 'organizationId' | 'accessToken'
+>;
+
+export type UsePlaystorePublishResult = {
+  status: PlaystorePublishStatus;
+  isSignedIn: boolean;
+  versionCode?: number;
+  error?: string;
+  /** Registry error code driving per-cause UX, e.g. versionCodeExists. */
+  errorCode?: string;
+  /** Warm up the Google sign-in script (e.g. on dialog open) so signInWithGoogle stays synchronous with the click. */
+  preloadGoogle: () => void;
+  signInWithGoogle: () => Promise<boolean>;
+  publish: (request: PlaystorePublishRequest) => Promise<PlaystorePublishResult | undefined>;
+  reset: () => void;
+};
+
+export function usePlaystorePublish({
+  registryApiUrl,
+  token,
+  organizationId,
+  googleClientId,
+}: UsePlaystorePublishOptions): UsePlaystorePublishResult {
+  const [status, setStatus] = useState<PlaystorePublishStatus>('idle');
+  const [isSignedIn, setIsSignedIn] = useState(false);
+  const [versionCode, setVersionCode] = useState<number | undefined>();
+  const [error, setError] = useState<string | undefined>();
+  const [errorCode, setErrorCode] = useState<string | undefined>();
+  // The token lives in a ref so publish() right after signInWithGoogle()
+  // in one handler sees it before React re-renders.
+  const accessTokenRef = useRef<string | undefined>(undefined);
+  // reset() bumps the generation so an abandoned in-flight call cannot
+  // overwrite the state it settles into.
+  const generationRef = useRef(0);
+  const busyRef = useRef(false);
+
+  const preloadGoogle = useCallback(() => {
+    void loadGoogleIdentityServices().catch(() => undefined);
+  }, []);
+
+  const signInWithGoogle = useCallback(async () => {
+    if (busyRef.current) {
+      return false;
+    }
+    if (!googleClientId) {
+      setError('Google OAuth client ID is not configured.');
+      setStatus('error');
+      return false;
+    }
+    busyRef.current = true;
+    const generation = generationRef.current;
+    setStatus('signing-in');
+    setError(undefined);
+    setErrorCode(undefined);
+    try {
+      const nextToken = await requestGoogleAccessToken({ clientId: googleClientId });
+      accessTokenRef.current = nextToken;
+      if (generation === generationRef.current) {
+        setIsSignedIn(true);
+        setStatus('ready');
+      }
+      return true;
+    } catch (caught) {
+      if (generation === generationRef.current) {
+        setError(errorMessage(caught));
+        setStatus('error');
+      }
+      return false;
+    } finally {
+      busyRef.current = false;
+    }
+  }, [googleClientId]);
+
+  const publish = useCallback(
+    async (request: PlaystorePublishRequest) => {
+      if (busyRef.current) {
+        return undefined;
+      }
+      if (!registryApiUrl) {
+        setError('Registry URL is not configured.');
+        setStatus('error');
+        return undefined;
+      }
+      const accessToken = accessTokenRef.current;
+      if (!accessToken) {
+        setError('Sign in with Google before publishing.');
+        setStatus('error');
+        return undefined;
+      }
+      busyRef.current = true;
+      const generation = generationRef.current;
+      setStatus('publishing');
+      setError(undefined);
+      setErrorCode(undefined);
+      try {
+        const result = await publishToPlaystore({
+          registryApiUrl,
+          token,
+          organizationId,
+          accessToken,
+          ...request,
+        });
+        if (generation === generationRef.current) {
+          setVersionCode(result.versionCode);
+          setStatus('published');
+        }
+        return result;
+      } catch (caught) {
+        if (generation === generationRef.current) {
+          setError(errorMessage(caught));
+          if (caught instanceof PlaystorePublishError) {
+            setErrorCode(caught.code);
+          }
+          setStatus('error');
+        }
+        return undefined;
+      } finally {
+        busyRef.current = false;
+      }
+    },
+    [registryApiUrl, token, organizationId],
+  );
+
+  const reset = useCallback(() => {
+    generationRef.current += 1;
+    setVersionCode(undefined);
+    setError(undefined);
+    setErrorCode(undefined);
+    setStatus(accessTokenRef.current ? 'ready' : 'idle');
+  }, []);
+
+  return {
+    status,
+    isSignedIn,
+    versionCode,
+    error,
+    errorCode,
+    preloadGoogle,
+    signInWithGoogle,
+    publish,
+    reset,
+  };
+}
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}

package/vite.config.ts

@@ -17,6 +17,8 @@ export default defineConfig({
         'device-build/react': resolve(__dirname, 'src/device-build/react.ts'),
         'device-install/index': resolve(__dirname, 'src/device-install/index.ts'),
         'device-install/react': resolve(__dirname, 'src/device-install/react.ts'),
+        'play-publish/index': resolve(__dirname, 'src/play-publish/index.ts'),
+        'play-publish/react': resolve(__dirname, 'src/play-publish/react.ts'),
       },
       name: 'LimrunUI',
       formats: ['es', 'cjs'],