@agent-foundry/studio 1.0.0

package/src/oss/uploader.ts

@@ -0,0 +1,254 @@
+/**
+ * Direct Uploader
+ *
+ * High-level interface for uploading build artifacts to OSS.
+ * Handles STS credential fetching, multipart upload, and progress tracking.
+ */
+
+import { AliOSSClient } from './client';
+import type {
+  UploadFile,
+  UploadProgress,
+  UploadResult,
+  UploadTokenResponse,
+} from './types';
+
+/**
+ * Configuration for DirectUploader
+ */
+export interface DirectUploaderConfig {
+  /** BFF base URL (e.g., "http://localhost:11001") */
+  bffBaseUrl: string;
+
+  /** Supabase JWT token for authentication */
+  authToken: string;
+
+  /** Request timeout in milliseconds */
+  timeout?: number;
+}
+
+/**
+ * Upload options
+ */
+export interface UploadOptions {
+  /** Project ID */
+  projectId: string;
+
+  /** Files to upload */
+  files: UploadFile[];
+
+  /** Optional: specific version string */
+  version?: string;
+
+  /** Progress callback */
+  onProgress?: (progress: UploadProgress) => void;
+}
+
+/**
+ * DirectUploader - handles the complete upload flow
+ *
+ * 1. Requests STS credentials from BFF
+ * 2. Uploads files directly to OSS
+ * 3. Notifies BFF of completion
+ *
+ * @example
+ * ```typescript
+ * const uploader = new DirectUploader({
+ *   bffBaseUrl: 'http://localhost:11001',
+ *   authToken: 'eyJ...',
+ * });
+ *
+ * const result = await uploader.upload({
+ *   projectId: 'project-uuid',
+ *   files: [
+ *     { path: 'index.html', content: indexHtml, contentType: 'text/html' },
+ *     { path: 'assets/main.js', content: mainJs, contentType: 'application/javascript' },
+ *   ],
+ *   onProgress: (p) => console.log(`${p.percent}%`),
+ * });
+ * ```
+ */
+export class DirectUploader {
+  private config: DirectUploaderConfig;
+
+  constructor(config: DirectUploaderConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Upload files to OSS
+   */
+  async upload(options: UploadOptions): Promise<UploadResult> {
+    const { projectId, files, version, onProgress } = options;
+
+    // Report preparing stage
+    if (onProgress) {
+      onProgress({
+        currentFile: '',
+        uploadedCount: 0,
+        totalCount: files.length,
+        uploadedBytes: 0,
+        totalBytes: 0,
+        percent: 0,
+        stage: 'preparing',
+      });
+    }
+
+    try {
+      // Step 1: Get upload token from BFF
+      const tokenResponse = await this.getUploadToken(projectId, version);
+
+      // Step 2: Create OSS client with STS credentials
+      const ossClient = new AliOSSClient({
+        region: tokenResponse.region,
+        bucket: tokenResponse.bucket,
+        credentials: tokenResponse.credentials,
+        timeout: this.config.timeout,
+      });
+
+      // Calculate total bytes
+      let totalBytes = 0;
+      for (const file of files) {
+        if (file.content instanceof Blob) {
+          totalBytes += file.content.size;
+        } else if (file.content instanceof ArrayBuffer) {
+          totalBytes += file.content.byteLength;
+        } else if (typeof file.content === 'string') {
+          totalBytes += new Blob([file.content]).size;
+        }
+      }
+
+      // Step 3: Upload files with progress tracking
+      let uploadedBytes = 0;
+      let uploadedCount = 0;
+
+      for (const file of files) {
+        // Get file size
+        let fileSize = 0;
+        if (file.content instanceof Blob) {
+          fileSize = file.content.size;
+        } else if (file.content instanceof ArrayBuffer) {
+          fileSize = file.content.byteLength;
+        } else if (typeof file.content === 'string') {
+          fileSize = new Blob([file.content]).size;
+        }
+
+        // Report progress before upload
+        if (onProgress) {
+          onProgress({
+            currentFile: file.path,
+            uploadedCount,
+            totalCount: files.length,
+            uploadedBytes,
+            totalBytes,
+            percent: Math.round((uploadedBytes / totalBytes) * 100),
+            stage: 'uploading',
+          });
+        }
+
+        // Upload file
+        const key = `${tokenResponse.keyPrefix}/${file.path}`.replace(/\/+/g, '/');
+        await ossClient.uploadFile(key, file.content, file.contentType);
+
+        uploadedBytes += fileSize;
+        uploadedCount++;
+      }
+
+      // Step 4: Notify BFF of completion
+      if (onProgress) {
+        onProgress({
+          currentFile: '',
+          uploadedCount: files.length,
+          totalCount: files.length,
+          uploadedBytes: totalBytes,
+          totalBytes,
+          percent: 100,
+          stage: 'finalizing',
+        });
+      }
+
+      const finalResult = await this.completeUpload(
+        tokenResponse.deploymentId,
+        tokenResponse.bucket,
+        tokenResponse.keyPrefix,
+        totalBytes,
+        files.length
+      );
+
+      return {
+        success: true,
+        deploymentId: tokenResponse.deploymentId,
+        url: finalResult.url,
+        bucket: tokenResponse.bucket,
+        keyPrefix: tokenResponse.keyPrefix,
+        totalBytes,
+        fileCount: files.length,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      return {
+        success: false,
+        deploymentId: '',
+        totalBytes: 0,
+        fileCount: 0,
+        error: errorMessage,
+      };
+    }
+  }
+
+  /**
+   * Request upload token from BFF
+   */
+  private async getUploadToken(
+    projectId: string,
+    version?: string
+  ): Promise<UploadTokenResponse> {
+    const response = await fetch(`${this.config.bffBaseUrl}/studio/oss/token`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.authToken}`,
+      },
+      body: JSON.stringify({ projectId, version }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to get upload token: ${error}`);
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Notify BFF that upload is complete
+   */
+  private async completeUpload(
+    deploymentId: string,
+    bucket: string,
+    keyPrefix: string,
+    totalBytes: number,
+    fileCount: number
+  ): Promise<{ url: string }> {
+    const response = await fetch(`${this.config.bffBaseUrl}/studio/deployments/${deploymentId}/complete`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.config.authToken}`,
+      },
+      body: JSON.stringify({
+        bucket,
+        keyPrefix,
+        totalBytes,
+        fileCount,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to complete upload: ${error}`);
+    }
+
+    return response.json();
+  }
+}

package/src/types/deployment.ts

@@ -0,0 +1,147 @@
+/**
+ * Deployment types
+ *
+ * A Deployment represents a build and upload of a project to Alibaba Cloud OSS.
+ */
+
+/**
+ * Deployment status enum
+ */
+export type DeploymentStatus =
+  | 'pending'    // Deployment created, waiting to start
+  | 'building'   // Running pnpm build
+  | 'uploading'  // Uploading to OSS
+  | 'published'  // Successfully deployed
+  | 'failed';    // Build or upload failed
+
+/**
+ * Deployment metadata stored as JSONB
+ */
+export interface DeploymentMetadata {
+  /** Git commit hash if available */
+  commitHash?: string;
+
+  /** Git branch name */
+  branch?: string;
+
+  /** Build duration in milliseconds */
+  buildDurationMs?: number;
+
+  /** Upload duration in milliseconds */
+  uploadDurationMs?: number;
+
+  /** Number of files uploaded */
+  fileCount?: number;
+
+  /** Node.js version used for build */
+  nodeVersion?: string;
+
+  /** Custom metadata from user */
+  custom?: Record<string, unknown>;
+}
+
+/**
+ * Deployment record
+ */
+export interface Deployment {
+  /** UUID primary key */
+  id: string;
+
+  /** Associated project ID */
+  projectId: string;
+
+  /** User who created the deployment */
+  userId: string;
+
+  /** Version string (semver or timestamp) */
+  version: string;
+
+  /** Current deployment status */
+  status: DeploymentStatus;
+
+  /** OSS bucket name */
+  ossBucket?: string;
+
+  /** Object key/path in OSS bucket */
+  ossKey?: string;
+
+  /** Public access URL for the deployed app */
+  ossUrl?: string;
+
+  /** Total bundle size in bytes */
+  bundleSizeBytes?: number;
+
+  /** Build output log */
+  buildLog?: string;
+
+  /** Error message if failed */
+  errorMessage?: string;
+
+  /** Additional metadata */
+  metadata: DeploymentMetadata;
+
+  /** ISO timestamp of creation */
+  createdAt: string;
+
+  /** ISO timestamp when published */
+  publishedAt?: string;
+}
+
+/**
+ * Input for creating a new deployment
+ */
+export interface CreateDeploymentInput {
+  projectId: string;
+  version?: string;  // Auto-generated if not provided
+  metadata?: Partial<DeploymentMetadata>;
+}
+
+/**
+ * Input for updating deployment status
+ */
+export interface UpdateDeploymentInput {
+  status?: DeploymentStatus;
+  ossBucket?: string;
+  ossKey?: string;
+  ossUrl?: string;
+  bundleSizeBytes?: number;
+  buildLog?: string;
+  errorMessage?: string;
+  metadata?: Partial<DeploymentMetadata>;
+  publishedAt?: string;
+}
+
+/**
+ * Deployment list filters
+ */
+export interface DeploymentListFilters {
+  /** Filter by project */
+  projectId?: string;
+
+  /** Filter by status */
+  status?: DeploymentStatus;
+
+  /** Limit number of results */
+  limit?: number;
+
+  /** Offset for pagination */
+  offset?: number;
+
+  /** Order by field */
+  orderBy?: 'createdAt' | 'publishedAt' | 'version';
+
+  /** Order direction */
+  orderDir?: 'asc' | 'desc';
+}
+
+/**
+ * Deployment progress event for real-time updates
+ */
+export interface DeploymentProgress {
+  deploymentId: string;
+  status: DeploymentStatus;
+  stage: 'init' | 'install' | 'build' | 'bundle' | 'upload' | 'finalize';
+  percent: number;
+  message?: string;
+  timestamp: string;
+}

package/src/types/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Type definitions for Agent Foundry Build Studio
+ */
+
+export * from './project';
+export * from './deployment';
+export * from './workspace';
+export * from './user';

package/src/types/project.ts

@@ -0,0 +1,114 @@
+/**
+ * Studio Project types
+ *
+ * A StudioProject represents a React/Vite project created and managed
+ * within the Build Studio desktop application.
+ */
+
+/**
+ * Supported frontend frameworks
+ */
+export type ProjectFramework = 'vite-react' | 'next' | 'remix' | 'vite-vue' | 'vite-svelte';
+
+/**
+ * Project configuration stored as JSONB in database
+ */
+export interface ProjectConfig {
+  /** Build command to execute (default: "pnpm build") */
+  buildCommand?: string;
+
+  /** Output directory for build artifacts (default: "dist") */
+  outputDir?: string;
+
+  /** Environment variables to inject during build */
+  envVars?: Record<string, string>;
+
+  /** Base URL for the deployed app */
+  baseUrl?: string;
+
+  /** Custom Vite config overrides */
+  viteConfig?: Record<string, unknown>;
+}
+
+/**
+ * Studio Project - a React/Vite project managed by Build Studio
+ */
+export interface StudioProject {
+  /** UUID primary key */
+  id: string;
+
+  /** Owner user ID (from Supabase Auth) */
+  userId: string;
+
+  /** Human-readable project name */
+  name: string;
+
+  /** URL-safe unique identifier (unique per user) */
+  slug: string;
+
+  /** Optional project description */
+  description?: string;
+
+  /** Local filesystem path to project root */
+  rootPath: string;
+
+  /** Frontend framework used */
+  framework: ProjectFramework;
+
+  /** Project configuration */
+  config: ProjectConfig;
+
+  /** Parent project ID if this is a fork/copy */
+  parentProjectId?: string;
+
+  /** ISO timestamp of creation */
+  createdAt: string;
+
+  /** ISO timestamp of last update */
+  updatedAt: string;
+}
+
+/**
+ * Input for creating a new project
+ */
+export interface CreateProjectInput {
+  name: string;
+  slug: string;
+  description?: string;
+  rootPath: string;
+  framework?: ProjectFramework;
+  config?: ProjectConfig;
+  parentProjectId?: string;
+}
+
+/**
+ * Input for updating a project
+ */
+export interface UpdateProjectInput {
+  name?: string;
+  description?: string;
+  config?: Partial<ProjectConfig>;
+}
+
+/**
+ * Project list filters
+ */
+export interface ProjectListFilters {
+  /** Filter by framework */
+  framework?: ProjectFramework;
+
+  /** Search by name (case-insensitive) */
+  search?: string;
+
+  /** Limit number of results */
+  limit?: number;
+
+  /** Offset for pagination */
+  offset?: number;
+
+  /** Order by field */
+  orderBy?: 'createdAt' | 'updatedAt' | 'name';
+
+  /** Order direction */
+  orderDir?: 'asc' | 'desc';
+}

package/src/types/user.ts

@@ -0,0 +1,91 @@
+/**
+ * User types
+ *
+ * StudioUser is linked to Supabase Auth user but may have
+ * additional Studio-specific metadata.
+ */
+
+/**
+ * User preferences for Studio
+ */
+export interface UserPreferences {
+  /** Default framework for new projects */
+  defaultFramework?: string;
+
+  /** Default build command */
+  defaultBuildCommand?: string;
+
+  /** Theme preference */
+  theme?: 'light' | 'dark' | 'system';
+
+  /** Editor font size */
+  editorFontSize?: number;
+
+  /** Show line numbers in editor */
+  showLineNumbers?: boolean;
+
+  /** Auto-save interval in seconds (0 = disabled) */
+  autoSaveInterval?: number;
+
+  /** Default chat panel width ratio (0.0 - 1.0) */
+  chatPanelRatio?: number;
+}
+
+/**
+ * Studio user - extends Supabase Auth user with Studio-specific data
+ */
+export interface StudioUser {
+  /** User ID from Supabase Auth */
+  id: string;
+
+  /** Email address */
+  email: string;
+
+  /** Display name */
+  displayName?: string;
+
+  /** Avatar URL */
+  avatarUrl?: string;
+
+  /** User preferences */
+  preferences: UserPreferences;
+
+  /** ISO timestamp of account creation */
+  createdAt: string;
+
+  /** ISO timestamp of last login */
+  lastLoginAt?: string;
+}
+
+/**
+ * Authentication state
+ */
+export interface AuthState {
+  /** Whether user is authenticated */
+  isAuthenticated: boolean;
+
+  /** Current user if authenticated */
+  user?: StudioUser;
+
+  /** Supabase access token */
+  accessToken?: string;
+
+  /** Token expiration timestamp */
+  expiresAt?: string;
+
+  /** Whether auth state is loading */
+  isLoading: boolean;
+}
+
+/**
+ * Login credentials
+ */
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+/**
+ * OAuth provider
+ */
+export type OAuthProvider = 'google' | 'github' | 'apple';