@comergehq/studio 0.1.2 → 0.1.4

package/src/core/services/http/public.ts

@@ -0,0 +1,33 @@
+import axios from "axios";
+
+import { BASE_URL } from "./baseUrl";
+
+const CLIENT_KEY_HEADER = "x-comerge-api-key";
+let clientApiKey: string | null = null;
+
+export const publicApi = axios.create({
+	baseURL: BASE_URL,
+	timeout: 30_000,
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "application/json",
+	},
+});
+
+export function setClientApiKey(apiKey: string) {
+	const trimmed = apiKey?.trim?.() ?? "";
+	if (!trimmed) {
+		throw new Error("comerge-studio: apiKey is required");
+	}
+	clientApiKey = trimmed;
+	publicApi.defaults.headers.common[CLIENT_KEY_HEADER] = trimmed;
+}
+
+publicApi.interceptors.request.use((config) => {
+	if (!clientApiKey) return config;
+	config.headers = config.headers ?? {};
+	(config.headers as any)[CLIENT_KEY_HEADER] = clientApiKey;
+	return config;
+});
+
+

package/src/core/services/supabase/auth.ts

@@ -0,0 +1,41 @@
+import type { User } from '@supabase/supabase-js';
+
+import { getSupabaseClient } from './client';
+
+export type EnsureAnonymousSessionResult = {
+  user: User;
+  isNew: boolean;
+};
+
+export type EnsureAuthenticatedSessionResult = {
+  user: User;
+};
+
+export async function ensureAuthenticatedSession(): Promise<EnsureAuthenticatedSessionResult> {
+  const supabase = getSupabaseClient();
+  const { data, error } = await supabase.auth.getSession();
+  if (error) throw error;
+  const user = data.session?.user ?? null;
+  if (!user) {
+    throw new Error('comerge-studio: no authenticated Supabase session found.');
+  }
+  return { user };
+}
+
+export async function ensureAnonymousSession(): Promise<EnsureAnonymousSessionResult> {
+  const supabase = getSupabaseClient();
+
+  const { data: sessionData, error: sessionError } = await supabase.auth.getSession();
+  if (sessionError) throw sessionError;
+
+  const existingUser = sessionData.session?.user ?? null;
+  if (existingUser) return { user: existingUser, isNew: false };
+
+  const { data, error } = await supabase.auth.signInAnonymously();
+  if (error) throw error;
+  if (!data.user) throw new Error('comerge-studio: anonymous sign-in returned no user');
+
+  return { user: data.user, isNew: true };
+}
+
+

package/src/core/services/supabase/client.ts

@@ -0,0 +1,43 @@
+import { createClient, type SupabaseClient } from '@supabase/supabase-js';
+
+let clientSingleton: SupabaseClient | null = null;
+let injectedClient: SupabaseClient | null = null;
+let hasInjectedClient = false;
+let runtimeConfig: { url: string; anonKey: string } | null = null;
+
+export function setSupabaseClient(client: SupabaseClient) {
+  injectedClient = client;
+  clientSingleton = client;
+  hasInjectedClient = true;
+}
+
+export function isSupabaseClientInjected(): boolean {
+  return hasInjectedClient;
+}
+
+export function setSupabaseConfig(config: { url: string; anonKey: string }) {
+  runtimeConfig = config;
+}
+
+export function getSupabaseClient(): SupabaseClient {
+  if (clientSingleton) return clientSingleton;
+  if (injectedClient) return injectedClient;
+
+  if (!runtimeConfig?.url) {
+    throw new Error('comerge-studio: Supabase config not initialized (missing url).');
+  }
+  if (!runtimeConfig?.anonKey) {
+    throw new Error('comerge-studio: Supabase config not initialized (missing anonKey).');
+  }
+
+  clientSingleton = createClient(runtimeConfig.url, runtimeConfig.anonKey, {
+    auth: {
+      autoRefreshToken: true,
+      persistSession: true,
+      detectSessionInUrl: false,
+    },
+  });
+
+  return clientSingleton;
+}
+

package/src/core/services/supabase/index.ts

@@ -0,0 +1,7 @@
+export { getSupabaseClient, setSupabaseClient } from './client';
+export type { SupabaseClient } from '@supabase/supabase-js';
+
+export { ensureAnonymousSession, ensureAuthenticatedSession } from './auth';
+export type { EnsureAnonymousSessionResult, EnsureAuthenticatedSessionResult } from './auth';
+
+

package/src/data/agent/remote.ts

@@ -0,0 +1,30 @@
+import { api } from '../../core/services/http';
+import type {
+  CreateAgentAppRequest,
+  EditAgentAppRequest,
+  AgentCreateAppResult,
+  AgentEditAppResult,
+} from './types';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+
+export interface AgentRemoteDataSource {
+  createApp(payload: CreateAgentAppRequest): Promise<ServiceResponse<AgentCreateAppResult>>;
+  editApp(payload: EditAgentAppRequest): Promise<ServiceResponse<AgentEditAppResult>>;
+}
+
+class AgentRemoteDataSourceImpl extends BaseRemote implements AgentRemoteDataSource {
+  async createApp(payload: CreateAgentAppRequest): Promise<ServiceResponse<AgentCreateAppResult>> {
+    const { data } = await api.post<ServiceResponse<AgentCreateAppResult>>('/v1/agent/createApp', payload);
+    return data;
+  }
+
+  async editApp(payload: EditAgentAppRequest): Promise<ServiceResponse<AgentEditAppResult>> {
+    const { data } = await api.post<ServiceResponse<AgentEditAppResult>>('/v1/agent/editApp', payload);
+    return data;
+  }
+}
+
+export const agentRemoteDataSource: AgentRemoteDataSource = new AgentRemoteDataSourceImpl();
+
+

package/src/data/agent/repository.ts

@@ -0,0 +1,34 @@
+import type { AgentRemoteDataSource } from './remote';
+import { agentRemoteDataSource } from './remote';
+import type {
+  AgentCreateAppResult,
+  AgentEditAppResult,
+  CreateAgentAppRequest,
+  EditAgentAppRequest,
+} from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface AgentRepository {
+  createApp(payload: CreateAgentAppRequest): Promise<AgentCreateAppResult>;
+  editApp(payload: EditAgentAppRequest): Promise<AgentEditAppResult>;
+}
+
+class AgentRepositoryImpl extends BaseRepository implements AgentRepository {
+  constructor(private readonly remote: AgentRemoteDataSource) {
+    super();
+  }
+
+  async createApp(payload: CreateAgentAppRequest): Promise<AgentCreateAppResult> {
+    const res = await this.remote.createApp(payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async editApp(payload: EditAgentAppRequest): Promise<AgentEditAppResult> {
+    const res = await this.remote.editApp(payload);
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const agentRepository: AgentRepository = new AgentRepositoryImpl(agentRemoteDataSource);
+
+

package/src/data/agent/types.ts

@@ -0,0 +1,28 @@
+export type CreateAgentAppRequest = {
+  prompt: string;
+  thread_id: string;
+  app_id?: string;
+  attachments?: AttachmentMeta[];
+};
+
+export type EditAgentAppRequest = {
+  prompt: string;
+  thread_id: string;
+  app_id: string;
+  attachments?: AttachmentMeta[];
+};
+
+export type AgentCreateAppResult = {
+  threadId: string;
+  projectId: string;
+  appId: string;
+};
+
+export type AgentEditAppResult = {
+  threadId: string;
+  appId: string;
+  sandboxExternalId: string;
+};
+
+import type { AttachmentMeta } from '../../data/attachment/types';
+

package/src/data/apps/bundles/remote.ts

@@ -0,0 +1,47 @@
+import { api } from '../../../core/services/http';
+import type { ServiceResponse } from '../../types';
+import { BaseRemote } from '../../base-remote';
+import type { Bundle, InitiateBundleRequest } from './types';
+
+export interface BundlesRemoteDataSource {
+  initiate(appId: string, payload: InitiateBundleRequest): Promise<ServiceResponse<Bundle>>;
+  getById(appId: string, bundleId: string): Promise<ServiceResponse<Bundle>>;
+  getSignedDownloadUrl(
+    appId: string,
+    bundleId: string,
+    options?: { redirect?: boolean }
+  ): Promise<ServiceResponse<{ url: string; redirect: boolean }>>;
+}
+
+class BundlesRemoteDataSourceImpl extends BaseRemote implements BundlesRemoteDataSource {
+  async initiate(appId: string, payload: InitiateBundleRequest): Promise<ServiceResponse<Bundle>> {
+    const { data } = await api.post<ServiceResponse<Bundle>>(
+      `/v1/apps/${encodeURIComponent(appId)}/bundles`,
+      payload
+    );
+    return data;
+  }
+
+  async getById(appId: string, bundleId: string): Promise<ServiceResponse<Bundle>> {
+    const { data } = await api.get<ServiceResponse<Bundle>>(
+      `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}`
+    );
+    return data;
+  }
+
+  async getSignedDownloadUrl(
+    appId: string,
+    bundleId: string,
+    options?: { redirect?: boolean }
+  ): Promise<ServiceResponse<{ url: string; redirect: boolean }>> {
+    const { data } = await api.get<ServiceResponse<{ url: string; redirect: boolean }>>(
+      `/v1/apps/${encodeURIComponent(appId)}/bundles/${encodeURIComponent(bundleId)}/download`,
+      { params: { redirect: options?.redirect ?? false } }
+    );
+    return data;
+  }
+}
+
+export const bundlesRemoteDataSource: BundlesRemoteDataSource = new BundlesRemoteDataSourceImpl();
+
+

package/src/data/apps/bundles/repository.ts

@@ -0,0 +1,35 @@
+import type { BundlesRemoteDataSource } from './remote';
+import { bundlesRemoteDataSource } from './remote';
+import type { Bundle, InitiateBundleRequest } from './types';
+import { BaseRepository } from '../../base-repository';
+
+export interface BundlesRepository {
+  initiate(appId: string, payload: InitiateBundleRequest): Promise<Bundle>;
+  getById(appId: string, bundleId: string): Promise<Bundle>;
+  getSignedDownloadUrl(appId: string, bundleId: string, options?: { redirect?: boolean }): Promise<{ url: string; redirect: boolean }>;
+}
+
+class BundlesRepositoryImpl extends BaseRepository implements BundlesRepository {
+  constructor(private readonly remote: BundlesRemoteDataSource) {
+    super();
+  }
+
+  async initiate(appId: string, payload: InitiateBundleRequest): Promise<Bundle> {
+    const res = await this.remote.initiate(appId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getById(appId: string, bundleId: string): Promise<Bundle> {
+    const res = await this.remote.getById(appId, bundleId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getSignedDownloadUrl(appId: string, bundleId: string, options?: { redirect?: boolean }): Promise<{ url: string; redirect: boolean }> {
+    const res = await this.remote.getSignedDownloadUrl(appId, bundleId, options);
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const bundlesRepository: BundlesRepository = new BundlesRepositoryImpl(bundlesRemoteDataSource);
+
+

package/src/data/apps/bundles/types.ts

@@ -0,0 +1,27 @@
+export type Platform = 'ios' | 'android';
+
+export type BundleStatus = 'pending' | 'building' | 'succeeded' | 'failed';
+
+export type Bundle = {
+  id: string;
+  appId: string;
+  fingerprint: string;
+  platform: Platform;
+  status: BundleStatus;
+  storageKey: string | null;
+  size: number | null;
+  checksumSha256: string | null;
+  contentType: string | null;
+  createdAt: string;
+  updatedAt: string;
+  expiresAt: string | null;
+};
+
+export type InitiateBundleRequest = {
+  commitId?: string;
+  platform: Platform;
+  expiresAt?: string; // ISO string
+  idempotencyKey?: string;
+};
+
+

package/src/data/apps/images/remote.ts

@@ -0,0 +1,61 @@
+import { api } from '../../../core/services/http';
+import type { ServiceResponse } from '../../types';
+import { BaseRemote } from '../../base-remote';
+
+export type GetAppImageSignedUrlOptions = {
+  variant?: string;
+  redirect?: boolean;
+};
+
+export type AppImageSignedUrlBatchResponse = {
+  urls: Record<string, string | null>;
+  errors?: Record<string, { message: string; statusCode: number }>;
+};
+
+export interface AppImagesRemoteDataSource {
+  getSignedUrl(
+    appId: string,
+    options?: GetAppImageSignedUrlOptions
+  ): Promise<ServiceResponse<{ url: string; redirect: boolean }>>;
+  getSignedUrlsBatch(
+    appIds: string[],
+    options?: Pick<GetAppImageSignedUrlOptions, 'variant'>
+  ): Promise<ServiceResponse<AppImageSignedUrlBatchResponse>>;
+}
+
+class AppImagesRemoteDataSourceImpl extends BaseRemote implements AppImagesRemoteDataSource {
+  async getSignedUrl(
+    appId: string,
+    options?: GetAppImageSignedUrlOptions
+  ): Promise<ServiceResponse<{ url: string; redirect: boolean }>> {
+    const { data } = await api.get<ServiceResponse<{ url: string; redirect: boolean }>>(
+      `/v1/apps/${encodeURIComponent(appId)}/image/url`,
+      {
+        params: {
+          variant: options?.variant,
+          redirect: options?.redirect ?? false,
+        },
+      }
+    );
+    return data;
+  }
+
+  async getSignedUrlsBatch(
+    appIds: string[],
+    options?: Pick<GetAppImageSignedUrlOptions, 'variant'>
+  ): Promise<ServiceResponse<AppImageSignedUrlBatchResponse>> {
+    const payload = {
+      appIds,
+      variant: options?.variant,
+    };
+    const { data } = await api.post<ServiceResponse<AppImageSignedUrlBatchResponse>>(
+      '/v1/apps/image/url/batch',
+      payload
+    );
+    return data;
+  }
+}
+
+export const appImagesRemoteDataSource: AppImagesRemoteDataSource = new AppImagesRemoteDataSourceImpl();
+
+

package/src/data/apps/images/repository.ts

@@ -0,0 +1,47 @@
+import type {
+  AppImageSignedUrlBatchResponse,
+  AppImagesRemoteDataSource,
+  GetAppImageSignedUrlOptions,
+} from './remote';
+import { appImagesRemoteDataSource } from './remote';
+import { BaseRepository } from '../../base-repository';
+
+export interface AppImagesRepository {
+  getSignedUrl(
+    appId: string,
+    options?: GetAppImageSignedUrlOptions
+  ): Promise<{ url: string; redirect: boolean }>;
+  getSignedUrlsBatch(
+    appIds: string[],
+    options?: Pick<GetAppImageSignedUrlOptions, 'variant'>
+  ): Promise<AppImageSignedUrlBatchResponse>;
+}
+
+class AppImagesRepositoryImpl extends BaseRepository implements AppImagesRepository {
+  constructor(private readonly remote: AppImagesRemoteDataSource) {
+    super();
+  }
+
+  async getSignedUrl(
+    appId: string,
+    options?: GetAppImageSignedUrlOptions
+  ): Promise<{ url: string; redirect: boolean }> {
+    const res = await this.remote.getSignedUrl(appId, options);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getSignedUrlsBatch(
+    appIds: string[],
+    options?: Pick<GetAppImageSignedUrlOptions, 'variant'>
+  ): Promise<AppImageSignedUrlBatchResponse> {
+    const res = await this.remote.getSignedUrlsBatch(appIds, options);
+    if (res.responseObject && !res.success) {
+      return res.responseObject;
+    }
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const appImagesRepository: AppImagesRepository = new AppImagesRepositoryImpl(appImagesRemoteDataSource);
+
+

package/src/data/apps/remote.ts

@@ -0,0 +1,97 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type {
+  App,
+  AppAnalyticsParams,
+  AppAnalyticsPoint,
+  AppInsights,
+  AppsSummary,
+  ForkAppRequest,
+  ImportGithubAppRequest,
+  ImportGithubAppResponse,
+  ListAppsSummaryParams,
+  ListLikedAppsParams,
+  ListPublicAppsParams,
+  LikedAppsList,
+} from './types';
+
+export interface AppsRemoteDataSource {
+  list(projectId?: string): Promise<ServiceResponse<App[]>>;
+  listPublicOthers(params?: ListPublicAppsParams): Promise<ServiceResponse<App[]>>;
+  listSummary(params?: ListAppsSummaryParams): Promise<ServiceResponse<AppsSummary>>;
+  listLiked(params?: ListLikedAppsParams): Promise<ServiceResponse<LikedAppsList>>;
+  getById(appId: string): Promise<ServiceResponse<App>>;
+  fork(appId: string, payload: ForkAppRequest): Promise<ServiceResponse<App>>;
+  getInsights(appId: string): Promise<ServiceResponse<AppInsights>>;
+  getAnalytics(appId: string, params: AppAnalyticsParams): Promise<ServiceResponse<AppAnalyticsPoint[]>>;
+  importFromGithub(payload: ImportGithubAppRequest): Promise<ServiceResponse<ImportGithubAppResponse>>;
+}
+
+class AppsRemoteDataSourceImpl extends BaseRemote implements AppsRemoteDataSource {
+  async list(projectId?: string): Promise<ServiceResponse<App[]>> {
+    const params = projectId ? { projectId } : undefined;
+    const { data } = await api.get<ServiceResponse<App[]>>('/v1/apps', { params });
+    return data;
+  }
+
+  async listPublicOthers(params?: ListPublicAppsParams): Promise<ServiceResponse<App[]>> {
+    const query = params ? { ...params } : undefined;
+    const { data } = await api.get<ServiceResponse<App[]>>('/v1/apps/public', { params: query });
+    return data;
+  }
+
+  async listSummary(params?: ListAppsSummaryParams): Promise<ServiceResponse<AppsSummary>> {
+    const query = params ? { ...params } : undefined;
+    const { data } = await api.get<ServiceResponse<AppsSummary>>('/v1/apps/summary', {
+      params: query,
+    });
+    return data;
+  }
+
+  async listLiked(params?: ListLikedAppsParams): Promise<ServiceResponse<LikedAppsList>> {
+    const query = params ? { ...params } : undefined;
+    const { data } = await api.get<ServiceResponse<LikedAppsList>>('/v1/apps/likes/mine', {
+      params: query,
+    });
+    return data;
+  }
+
+  async getById(appId: string): Promise<ServiceResponse<App>> {
+    const { data } = await api.get<ServiceResponse<App>>(`/v1/apps/${encodeURIComponent(appId)}`);
+    return data;
+  }
+
+  async fork(appId: string, payload: ForkAppRequest): Promise<ServiceResponse<App>> {
+    const { data } = await api.post<ServiceResponse<App>>(`/v1/apps/${encodeURIComponent(appId)}/fork`, payload);
+    return data;
+  }
+
+  async importFromGithub(payload: ImportGithubAppRequest): Promise<ServiceResponse<ImportGithubAppResponse>> {
+    const { data } = await api.post<ServiceResponse<ImportGithubAppResponse>>('/v1/apps/import/github', payload);
+    return data;
+  }
+
+  async getInsights(appId: string): Promise<ServiceResponse<AppInsights>> {
+    const { data } = await api.get<ServiceResponse<AppInsights>>(
+      `/v1/apps/${encodeURIComponent(appId)}/insights`,
+    );
+    return data;
+  }
+
+  async getAnalytics(
+    appId: string,
+    params: AppAnalyticsParams,
+  ): Promise<ServiceResponse<AppAnalyticsPoint[]>> {
+    const query = { ...params };
+    const { data } = await api.get<ServiceResponse<AppAnalyticsPoint[]>>(
+      `/v1/apps/${encodeURIComponent(appId)}/analytics`,
+      { params: query },
+    );
+    return data;
+  }
+}
+
+export const appsRemoteDataSource: AppsRemoteDataSource = new AppsRemoteDataSourceImpl();
+
+