hackerrun 0.1.0

package/src/lib/platform-client.ts

@@ -0,0 +1,637 @@
+// Platform API client - Single source of truth for all app state and VMs
+
+export interface VMNode {
+  name: string;
+  id: string;
+  ipv4?: string;  // Only for gateway VMs
+  ipv6?: string;  // All VMs get IPv6
+  ip?: string;    // Legacy field (deprecated, use ipv6)
+  isPrimary: boolean;
+}
+
+export interface AppCluster {
+  appName: string;
+  domainName?: string;  // Railway-style domain (e.g., "laughing-buddha")
+  location: string;
+  nodes: VMNode[];
+  uncloudContext: string;
+  createdAt: string;
+  lastDeployedAt?: string;
+}
+
+const PLATFORM_API_URL = process.env.HACKERRUN_API_URL || 'http://localhost:3000';
+
+export interface CreateVMParams {
+  name: string;
+  location: string;
+  size: string;
+  storage_size?: number;  // Storage size in GB (default varies by size)
+  unix_user: string;
+  public_key: string;
+  boot_image: string;
+  enable_ip4?: boolean;  // Default: false (IPv6-only)
+  private_subnet_id?: string;  // Put VM in specific private subnet for NAT64 routing
+}
+
+export interface UbicloudVM {
+  id: string;
+  name: string;
+  location: string;
+  size: string;
+  unix_user: string;
+  public_key: string;
+  boot_image: string;
+  state: string;
+  status?: string;
+  ip4?: string;
+  ip6?: string;
+}
+
+export class PlatformClient {
+  constructor(private authToken: string) {}
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: any
+  ): Promise<T> {
+    const url = `${PLATFORM_API_URL}${path}`;
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${this.authToken}`,
+      'Content-Type': 'application/json',
+      // FIX STALE CONNECTION: If retry logic below doesn't reliably fix
+      // "SocketError: other side closed" errors, uncomment this line and
+      // remove the retry logic in the catch block below.
+      // 'Connection': 'close',
+    };
+
+    const doFetch = () => fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    let response: Response;
+    try {
+      response = await doFetch();
+    } catch (error) {
+      // STALE CONNECTION RETRY: Node.js fetch (undici) reuses TCP connections.
+      // After spawnSync operations, connections may become stale (server closed them).
+      // Retry once on UND_ERR_SOCKET errors to establish a fresh connection.
+      // If this doesn't work reliably, use 'Connection: close' header instead.
+      const isSocketError = error instanceof Error &&
+        (error.cause as any)?.code === 'UND_ERR_SOCKET';
+      if (isSocketError) {
+        response = await doFetch();
+      } else {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to connect to platform API (${url}): ${errMsg}`);
+      }
+    }
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage: string;
+      try {
+        const errorJson = JSON.parse(errorText);
+        errorMessage = errorJson.error || response.statusText;
+      } catch {
+        errorMessage = errorText || response.statusText;
+      }
+      throw new Error(`API error (${response.status}): ${errorMessage}`);
+    }
+
+    return response.json();
+  }
+
+  // ==================== App State Management ====================
+
+  /**
+   * List all apps for the authenticated user
+   */
+  async listApps(): Promise<AppCluster[]> {
+    const { apps } = await this.request<{ apps: AppCluster[] }>('GET', '/api/apps');
+    return apps;
+  }
+
+  /**
+   * Get a specific app by name
+   */
+  async getApp(appName: string): Promise<AppCluster | null> {
+    try {
+      const { app } = await this.request<{ app: AppCluster }>('GET', `/api/apps/${appName}`);
+      return app;
+    } catch (error: any) {
+      if (error.message.includes('404') || error.message.includes('not found')) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Create or update an app
+   * Returns the app with auto-generated domainName
+   */
+  async saveApp(cluster: AppCluster): Promise<AppCluster> {
+    const { app } = await this.request<{ app: AppCluster }>('POST', '/api/apps', {
+      appName: cluster.appName,
+      location: cluster.location,
+      uncloudContext: cluster.uncloudContext,
+      nodes: cluster.nodes.map(node => ({
+        name: node.name,
+        id: node.id,
+        ipv4: node.ipv4,
+        ipv6: node.ipv6,
+        isPrimary: node.isPrimary,
+      })),
+    });
+    return app;
+  }
+
+  /**
+   * Update app's last deployed timestamp
+   */
+  async updateLastDeployed(appName: string): Promise<void> {
+    await this.request('PATCH', `/api/apps/${appName}`, {
+      lastDeployedAt: new Date().toISOString(),
+    });
+  }
+
+  /**
+   * Rename an app (per-user unique)
+   */
+  async renameApp(currentAppName: string, newAppName: string): Promise<AppCluster> {
+    const { app } = await this.request<{ app: AppCluster }>('PATCH', `/api/apps/${currentAppName}`, {
+      newAppName,
+    });
+    return app;
+  }
+
+  /**
+   * Rename app's domain (globally unique)
+   */
+  async renameDomain(appName: string, newDomainName: string): Promise<AppCluster> {
+    const { app } = await this.request<{ app: AppCluster }>('PATCH', `/api/apps/${appName}`, {
+      newDomainName,
+    });
+    return app;
+  }
+
+  /**
+   * Delete an app
+   */
+  async deleteApp(appName: string): Promise<void> {
+    await this.request('DELETE', `/api/apps/${appName}`);
+  }
+
+  /**
+   * Check if app exists
+   */
+  async hasApp(appName: string): Promise<boolean> {
+    const app = await this.getApp(appName);
+    return app !== null;
+  }
+
+  /**
+   * Get primary node for an app
+   */
+  async getPrimaryNode(appName: string): Promise<VMNode | null> {
+    const app = await this.getApp(appName);
+    return app?.nodes.find(node => node.isPrimary) || null;
+  }
+
+  // ==================== VM Operations (Proxied to Ubicloud) ====================
+
+  /**
+   * List all VMs for the user's Ubicloud project
+   */
+  async listVMs(): Promise<UbicloudVM[]> {
+    const { vms } = await this.request<{ vms: UbicloudVM[] }>('GET', '/api/vms');
+    return vms;
+  }
+
+  /**
+   * Create a new VM
+   */
+  async createVM(params: CreateVMParams): Promise<UbicloudVM> {
+    const { vm } = await this.request<{ vm: UbicloudVM }>('POST', '/api/vms', params);
+    return vm;
+  }
+
+  /**
+   * Get a specific VM
+   */
+  async getVM(location: string, vmName: string): Promise<UbicloudVM> {
+    const { vm } = await this.request<{ vm: UbicloudVM }>(
+      'GET',
+      `/api/vms/${location}/${vmName}`
+    );
+    return vm;
+  }
+
+  /**
+   * Delete a VM
+   */
+  async deleteVM(location: string, vmName: string): Promise<void> {
+    await this.request('DELETE', `/api/vms/${location}/${vmName}`);
+  }
+
+  // ==================== Uncloud Config Management ====================
+
+  /**
+   * Upload uncloud config to platform
+   */
+  async uploadUncloudConfig(configYaml: string): Promise<void> {
+    await this.request('POST', '/api/uncloud/config', { config: configYaml });
+  }
+
+  /**
+   * Download uncloud config from platform
+   */
+  async downloadUncloudConfig(): Promise<string | null> {
+    try {
+      const { config } = await this.request<{ config: string }>('GET', '/api/uncloud/config');
+      return config;
+    } catch (error: any) {
+      if (error.message.includes('404') || error.message.includes('not found')) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  // ==================== Gateway Management ====================
+
+  /**
+   * Get gateway info for a location
+   */
+  async getGateway(location: string): Promise<{
+    vmId: string;
+    ipv4: string;
+    ipv6: string;
+    privateIpv6?: string;  // Private subnet IPv6 for NAT64 routing
+    subnetId?: string;     // Private subnet ID for app VMs
+    subnetName?: string;
+    wireguardPublicKey?: string;  // WireGuard public key for NAT64 tunnel
+    wireguardPort?: number;       // WireGuard listen port (default 51820)
+    tunnelId: string;
+    location: string;
+  } | null> {
+    try {
+      const { gateway } = await this.request<{
+        gateway: {
+          vmId: string;
+          ipv4: string;
+          ipv6: string;
+          privateIpv6?: string;
+          subnetId?: string;
+          subnetName?: string;
+          wireguardPublicKey?: string;
+          wireguardPort?: number;
+          tunnelId: string;
+          location: string;
+        };
+      }>('GET', `/api/gateway?location=${encodeURIComponent(location)}`);
+      return gateway;
+    } catch (error: any) {
+      if (error.message.includes('404') || error.message.includes('not found')) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  // ==================== Route Management ====================
+
+  /**
+   * Register a route for an app (maps hostname to VM IPv6)
+   */
+  async registerRoute(appName: string, backendIpv6: string, backendPort: number = 443): Promise<{
+    hostname: string;
+    fullUrl: string;
+  }> {
+    const { route } = await this.request<{
+      route: { hostname: string; fullUrl: string };
+    }>('POST', '/api/routes', {
+      appName,
+      backendIpv6,
+      backendPort,
+    });
+    return route;
+  }
+
+  /**
+   * Delete routes for an app
+   */
+  async deleteRoute(appName: string): Promise<void> {
+    await this.request('DELETE', `/api/routes/${encodeURIComponent(appName)}`);
+  }
+
+  // ==================== Gateway Route Sync ====================
+
+  /**
+   * Sync gateway Caddy configuration for a location
+   * This updates the gateway's reverse proxy config with current routes
+   */
+  async syncGatewayRoutes(location: string): Promise<{ routeCount: number }> {
+    const result = await this.request<{
+      success: boolean;
+      routeCount: number;
+    }>('POST', '/api/gateway/sync', { location });
+    return { routeCount: result.routeCount };
+  }
+
+  // ==================== SSH Certificate Management ====================
+
+  /**
+   * Get platform SSH keys (CA public key + platform public key for VM creation)
+   */
+  async getPlatformSSHKeys(): Promise<{
+    caPublicKey: string;
+    platformPublicKey: string;
+  }> {
+    return this.request<{
+      caPublicKey: string;
+      platformPublicKey: string;
+    }>('GET', '/api/platform/ssh-keys');
+  }
+
+  /**
+   * Initialize platform SSH keys (creates them if they don't exist)
+   */
+  async initPlatformSSHKeys(): Promise<{
+    caPublicKey: string;
+    platformPublicKey: string;
+  }> {
+    return this.request<{
+      success: boolean;
+      caPublicKey: string;
+      platformPublicKey: string;
+    }>('POST', '/api/platform/ssh-keys');
+  }
+
+  /**
+   * Request a signed SSH certificate for accessing an app's VMs
+   * Returns a short-lived certificate (5 min) signed by the platform CA
+   */
+  async requestSSHCertificate(appName: string, publicKey: string): Promise<{
+    certificate: string;
+    validityMinutes: number;
+  }> {
+    return this.request<{
+      certificate: string;
+      validityMinutes: number;
+    }>('POST', `/api/apps/${appName}/ssh-certificate`, { publicKey });
+  }
+
+  // ==================== VM Setup ====================
+
+  /**
+   * Setup a newly created VM (DNS64, NAT64, SSH CA, Docker, uncloud)
+   * This runs all configuration using the platform SSH key
+   */
+  async setupVM(vmIp: string, location: string, appName: string): Promise<void> {
+    await this.request<{ success: boolean }>('POST', '/api/vms/setup', {
+      vmIp,
+      location,
+      appName,
+    });
+  }
+
+  // ==================== Environment Variables ====================
+
+  /**
+   * Set a single environment variable
+   */
+  async setEnvVar(appName: string, key: string, value: string): Promise<void> {
+    await this.request('POST', `/api/apps/${appName}/env`, { key, value });
+  }
+
+  /**
+   * Set multiple environment variables at once
+   */
+  async setEnvVars(appName: string, vars: Record<string, string>): Promise<void> {
+    await this.request('POST', `/api/apps/${appName}/env`, { vars });
+  }
+
+  /**
+   * List environment variables (values are masked)
+   */
+  async listEnvVars(appName: string): Promise<Array<{ key: string; valueLength: number }>> {
+    const { vars } = await this.request<{
+      vars: Array<{ key: string; valueLength: number }>;
+    }>('GET', `/api/apps/${appName}/env`);
+    return vars;
+  }
+
+  /**
+   * Remove an environment variable
+   */
+  async unsetEnvVar(appName: string, key: string): Promise<void> {
+    await this.request('DELETE', `/api/apps/${appName}/env/${encodeURIComponent(key)}`);
+  }
+
+  // ==================== GitHub Connection ====================
+
+  /**
+   * Create app metadata without creating VM (for connect-before-deploy flow)
+   */
+  async createAppMetadata(appName: string, location?: string): Promise<AppCluster> {
+    const { app } = await this.request<{ app: AppCluster }>('POST', '/api/apps', {
+      appName,
+      location: location || 'eu-central-h1',
+      metadataOnly: true,  // Signal that we don't want to create VM yet
+    });
+    return app;
+  }
+
+  /**
+   * Initiate GitHub App installation flow
+   */
+  async initiateGitHubConnect(): Promise<{ authUrl: string; stateToken: string }> {
+    return this.request<{ authUrl: string; stateToken: string }>('POST', '/api/github/connect');
+  }
+
+  /**
+   * Poll for GitHub App installation completion
+   */
+  async pollGitHubConnect(stateToken: string): Promise<{
+    status: 'pending' | 'complete' | 'expired';
+    installationId?: number;
+  }> {
+    return this.request<{
+      status: 'pending' | 'complete' | 'expired';
+      installationId?: number;
+    }>('GET', `/api/github/connect/poll?state=${encodeURIComponent(stateToken)}`);
+  }
+
+  /**
+   * Get current user's GitHub App installation
+   */
+  async getGitHubInstallation(): Promise<{
+    installationId: number;
+    accountLogin: string;
+  } | null> {
+    try {
+      const { installation } = await this.request<{
+        installation: {
+          installationId: number;
+          accountLogin: string;
+        } | null;
+      }>('GET', '/api/github/installation');
+      return installation;
+    } catch (error: any) {
+      if (error.message.includes('404') || error.message.includes('not found')) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * List repositories accessible via GitHub App installation
+   */
+  async listAccessibleRepos(): Promise<Array<{
+    fullName: string;
+    name: string;
+    private: boolean;
+    defaultBranch: string;
+  }>> {
+    const { repos } = await this.request<{
+      repos: Array<{
+        fullName: string;
+        name: string;
+        private: boolean;
+        defaultBranch: string;
+      }>;
+    }>('GET', '/api/github/repos');
+    return repos;
+  }
+
+  /**
+   * Connect a repository to an app
+   */
+  async connectRepo(appName: string, repoFullName: string, branch?: string): Promise<void> {
+    await this.request('POST', `/api/apps/${appName}/repo`, {
+      repoFullName,
+      branch: branch || 'main',
+    });
+  }
+
+  /**
+   * Get connected repository for an app
+   */
+  async getConnectedRepo(appName: string): Promise<{
+    repoFullName: string;
+    branch: string;
+  } | null> {
+    try {
+      const { repo } = await this.request<{
+        repo: {
+          repoFullName: string;
+          branch: string;
+        } | null;
+      }>('GET', `/api/apps/${appName}/repo`);
+      return repo;
+    } catch (error: any) {
+      if (error.message.includes('404') || error.message.includes('not found')) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Disconnect repository from an app
+   */
+  async disconnectRepo(appName: string): Promise<void> {
+    await this.request('DELETE', `/api/apps/${appName}/repo`);
+  }
+
+  // ==================== Builds ====================
+
+  /**
+   * List builds for an app
+   */
+  async listBuilds(appName: string, limit: number = 10): Promise<Array<{
+    id: number;
+    commitSha: string;
+    commitMsg: string | null;
+    branch: string;
+    status: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+  }>> {
+    const { builds } = await this.request<{
+      builds: Array<{
+        id: number;
+        commitSha: string;
+        commitMsg: string | null;
+        branch: string;
+        status: string;
+        startedAt: string | null;
+        completedAt: string | null;
+        createdAt: string;
+      }>;
+    }>('GET', `/api/apps/${appName}/builds?limit=${limit}`);
+    return builds;
+  }
+
+  /**
+   * Get build details
+   */
+  async getBuild(appName: string, buildId: number): Promise<{
+    id: number;
+    commitSha: string;
+    commitMsg: string | null;
+    branch: string;
+    status: string;
+    logs: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+  }> {
+    const { build } = await this.request<{
+      build: {
+        id: number;
+        commitSha: string;
+        commitMsg: string | null;
+        branch: string;
+        status: string;
+        logs: string | null;
+        startedAt: string | null;
+        completedAt: string | null;
+        createdAt: string;
+      };
+    }>('GET', `/api/apps/${appName}/builds/${buildId}`);
+    return build;
+  }
+
+  /**
+   * Get build events (for live streaming)
+   */
+  async getBuildEvents(appName: string, buildId: number, after?: Date): Promise<Array<{
+    id: number;
+    timestamp: string;
+    stage: string;
+    status: string;
+    message: string | null;
+  }>> {
+    let url = `/api/apps/${appName}/builds/${buildId}/events`;
+    if (after) {
+      url += `?after=${encodeURIComponent(after.toISOString())}`;
+    }
+    const { events } = await this.request<{
+      events: Array<{
+        id: number;
+        timestamp: string;
+        stage: string;
+        status: string;
+        message: string | null;
+      }>;
+    }>('GET', url);
+    return events;
+  }
+}