start-os/web/projects/ui/src/app/services/api/embassy-live-api.service.ts

import { Inject, Injectable } from '@angular/core'
import {
  HttpOptions,
  HttpService,
  isRpcError,
  Log,
  Method,
  RpcError,
  RPCOptions,
  SetupStatus,
} from '@start9labs/shared'
import { ApiService } from './embassy-api.service'
import { BackupTargetType, Metrics, RR } from './api.types'
import { ConfigService } from '../config.service'
import { webSocket, WebSocketSubjectConfig } from 'rxjs/webSocket'
import { Observable, filter, firstValueFrom } from 'rxjs'
import { AuthService } from '../auth.service'
import { DOCUMENT } from '@angular/common'
import { DataModel } from '../patch-db/data-model'
import { PatchDB, pathFromArray, Update } from 'patch-db-client'
import { getServerInfo } from 'src/app/util/get-server-info'

@Injectable()
export class LiveApiService extends ApiService {
  constructor(
    @Inject(DOCUMENT) private readonly document: Document,
    private readonly http: HttpService,
    private readonly config: ConfigService,
    private readonly auth: AuthService,
    private readonly patch: PatchDB<DataModel>,
  ) {
    super()

    // @ts-ignore
    this.document.defaultView.rpcClient = this
  }

  // for getting static files: ex icons, instructions, licenses
  async getStatic(url: string): Promise<string> {
    return this.httpRequest({
      method: Method.GET,
      url,
      responseType: 'text',
    })
  }

  // for sideloading packages
  async uploadPackage(guid: string, body: Blob): Promise<void> {
    return this.httpRequest({
      method: Method.POST,
      body,
      url: `/rest/rpc/${guid}`,
      responseType: 'text',
    })
  }

  async uploadFile(body: Blob): Promise<string> {
    return this.httpRequest({
      method: Method.POST,
      body,
      url: `/rest/upload`,
      responseType: 'text',
    })
  }

  // db

  async setDbValue<T>(
    pathArr: Array<string | number>,
    value: T,
  ): Promise<RR.SetDBValueRes> {
    const pointer = pathFromArray(pathArr)
    const params: RR.SetDBValueReq<T> = { pointer, value }
    return this.rpcRequest({ method: 'db.put.ui', params })
  }

  // auth

  async login(params: RR.LoginReq): Promise<RR.loginRes> {
    return this.rpcRequest({ method: 'auth.login', params })
  }

  async logout(params: RR.LogoutReq): Promise<RR.LogoutRes> {
    return this.rpcRequest({ method: 'auth.logout', params })
  }

  async getSessions(params: RR.GetSessionsReq): Promise<RR.GetSessionsRes> {
    return this.rpcRequest({ method: 'auth.session.list', params })
  }

  async killSessions(params: RR.KillSessionsReq): Promise<RR.KillSessionsRes> {
    return this.rpcRequest({ method: 'auth.session.kill', params })
  }

  async resetPassword(
    params: RR.ResetPasswordReq,
  ): Promise<RR.ResetPasswordRes> {
    return this.rpcRequest({ method: 'auth.reset-password', params })
  }

  // server

  async echo(params: RR.EchoReq, urlOverride?: string): Promise<RR.EchoRes> {
    return this.rpcRequest({ method: 'echo', params }, urlOverride)
  }

  openPatchWebsocket$(): Observable<Update<DataModel>> {
    const config: WebSocketSubjectConfig<Update<DataModel>> = {
      url: `/db`,
      closeObserver: {
        next: val => {
          if (val.reason === 'UNAUTHORIZED') this.auth.setUnverified()
        },
      },
    }

    return this.openWebsocket(config)
  }

  openLogsWebsocket$(config: WebSocketSubjectConfig<Log>): Observable<Log> {
    return this.openWebsocket(config)
  }

  openMetricsWebsocket$(
    config: WebSocketSubjectConfig<Metrics>,
  ): Observable<Metrics> {
    return this.openWebsocket(config)
  }

  async getSystemTime(
    params: RR.GetSystemTimeReq,
  ): Promise<RR.GetSystemTimeRes> {
    return this.rpcRequest({ method: 'server.time', params })
  }

  async getServerLogs(
    params: RR.GetServerLogsReq,
  ): Promise<RR.GetServerLogsRes> {
    return this.rpcRequest({ method: 'server.logs', params })
  }

  async getKernelLogs(
    params: RR.GetServerLogsReq,
  ): Promise<RR.GetServerLogsRes> {
    return this.rpcRequest({ method: 'server.kernel-logs', params })
  }

  async getTorLogs(params: RR.GetServerLogsReq): Promise<RR.GetServerLogsRes> {
    return this.rpcRequest({ method: 'net.tor.logs', params })
  }

  async followServerLogs(
    params: RR.FollowServerLogsReq,
  ): Promise<RR.FollowServerLogsRes> {
    return this.rpcRequest({ method: 'server.logs.follow', params })
  }

  async followKernelLogs(
    params: RR.FollowServerLogsReq,
  ): Promise<RR.FollowServerLogsRes> {
    return this.rpcRequest({ method: 'server.kernel-logs.follow', params })
  }

  async followTorLogs(
    params: RR.FollowServerLogsReq,
  ): Promise<RR.FollowServerLogsRes> {
    return this.rpcRequest({ method: 'net.tor.logs.follow', params })
  }

  async getServerMetrics(
    params: RR.GetServerMetricsReq,
  ): Promise<RR.GetServerMetricsRes> {
    return this.rpcRequest({ method: 'server.metrics', params })
  }

  async updateServer(url?: string): Promise<RR.UpdateServerRes> {
    const params = {
      marketplaceUrl: url || this.config.marketplace.start9,
    }
    return this.rpcRequest({ method: 'server.update', params })
  }

  async setServerClearnetAddress(
    params: RR.SetServerClearnetAddressReq,
  ): Promise<RR.SetServerClearnetAddressRes> {
    return this.rpcRequest({ method: 'server.set-clearnet', params })
  }

  async restartServer(
    params: RR.RestartServerReq,
  ): Promise<RR.RestartServerRes> {
    return this.rpcRequest({ method: 'server.restart', params })
  }

  async shutdownServer(
    params: RR.ShutdownServerReq,
  ): Promise<RR.ShutdownServerRes> {
    return this.rpcRequest({ method: 'server.shutdown', params })
  }

  async systemRebuild(
    params: RR.RestartServerReq,
  ): Promise<RR.RestartServerRes> {
    return this.rpcRequest({ method: 'server.rebuild', params })
  }

  async repairDisk(params: RR.RestartServerReq): Promise<RR.RestartServerRes> {
    return this.rpcRequest({ method: 'disk.repair', params })
  }

  async resetTor(params: RR.ResetTorReq): Promise<RR.ResetTorRes> {
    return this.rpcRequest({ method: 'net.tor.reset', params })
  }

  async setOsOutboundProxy(
    params: RR.SetOsOutboundProxyReq,
  ): Promise<RR.SetOsOutboundProxyRes> {
    return this.rpcRequest({ method: 'server.proxy.set-outbound', params })
  }

  // marketplace URLs

  async marketplaceProxy<T>(
    path: string,
    qp: Record<string, string>,
    baseUrl: string,
  ): Promise<T> {
    const fullUrl = `${baseUrl}${path}?${new URLSearchParams(qp).toString()}`
    return this.rpcRequest({
      method: 'marketplace.get',
      params: { url: fullUrl },
    })
  }

  async getEos(): Promise<RR.GetMarketplaceEosRes> {
    const { id } = await getServerInfo(this.patch)
    const qp: RR.GetMarketplaceEosReq = { serverId: id }

    return this.marketplaceProxy(
      '/eos/v0/latest',
      qp,
      this.config.marketplace.start9,
    )
  }

  // notification

  async getNotifications(
    params: RR.GetNotificationsReq,
  ): Promise<RR.GetNotificationsRes> {
    return this.rpcRequest({ method: 'notification.list', params })
  }

  async deleteNotifications(
    params: RR.DeleteNotificationReq,
  ): Promise<RR.DeleteNotificationRes> {
    return this.rpcRequest({ method: 'notification.delete', params })
  }

  async markSeenNotifications(
    params: RR.MarkSeenNotificationReq,
  ): Promise<RR.MarkSeenNotificationRes> {
    return this.rpcRequest({ method: 'notification.mark-seen', params })
  }

  async markSeenAllNotifications(
    params: RR.MarkSeenAllNotificationsReq,
  ): Promise<RR.MarkSeenAllNotificationsRes> {
    return this.rpcRequest({
      method: 'notification.mark-seen-before',
      params,
    })
  }

  async markUnseenNotifications(
    params: RR.MarkUnseenNotificationReq,
  ): Promise<RR.MarkUnseenNotificationRes> {
    return this.rpcRequest({ method: 'notification.mark-unseen', params })
  }

  // network

  async addProxy(params: RR.AddProxyReq): Promise<RR.AddProxyRes> {
    return this.rpcRequest({ method: 'net.proxy.add', params })
  }

  async updateProxy(params: RR.UpdateProxyReq): Promise<RR.UpdateProxyRes> {
    return this.rpcRequest({ method: 'net.proxy.update', params })
  }

  async deleteProxy(params: RR.DeleteProxyReq): Promise<RR.DeleteProxyRes> {
    return this.rpcRequest({ method: 'net.proxy.delete', params })
  }

  // domains

  async claimStart9ToDomain(
    params: RR.ClaimStart9ToReq,
  ): Promise<RR.ClaimStart9ToRes> {
    return this.rpcRequest({ method: 'net.domain.me.claim', params })
  }

  async deleteStart9ToDomain(
    params: RR.DeleteStart9ToReq,
  ): Promise<RR.DeleteStart9ToRes> {
    return this.rpcRequest({ method: 'net.domain.me.delete', params })
  }

  async addDomain(params: RR.AddDomainReq): Promise<RR.AddDomainRes> {
    return this.rpcRequest({ method: 'net.domain.add', params })
  }

  async deleteDomain(params: RR.DeleteDomainReq): Promise<RR.DeleteDomainRes> {
    return this.rpcRequest({ method: 'net.domain.delete', params })
  }

  // port forwards

  async overridePortForward(
    params: RR.OverridePortReq,
  ): Promise<RR.OverridePortRes> {
    return this.rpcRequest({ method: 'net.port-forwards.override', params })
  }

  // wifi

  async enableWifi(params: RR.EnableWifiReq): Promise<RR.EnableWifiRes> {
    return this.rpcRequest({ method: 'wifi.enable', params })
  }

  async getWifi(
    params: RR.GetWifiReq,
    timeout?: number,
  ): Promise<RR.GetWifiRes> {
    return this.rpcRequest({ method: 'wifi.get', params, timeout })
  }

  async addWifi(params: RR.AddWifiReq): Promise<RR.AddWifiRes> {
    return this.rpcRequest({ method: 'wifi.add', params })
  }

  async connectWifi(params: RR.ConnectWifiReq): Promise<RR.ConnectWifiRes> {
    return this.rpcRequest({ method: 'wifi.connect', params })
  }

  async deleteWifi(params: RR.DeleteWifiReq): Promise<RR.DeleteWifiRes> {
    return this.rpcRequest({ method: 'wifi.delete', params })
  }

  // email

  async testEmail(params: RR.TestEmailReq): Promise<RR.TestEmailRes> {
    return this.rpcRequest({ method: 'email.test', params })
  }

  async configureEmail(
    params: RR.ConfigureEmailReq,
  ): Promise<RR.ConfigureEmailRes> {
    return this.rpcRequest({ method: 'email.configure', params })
  }

  // ssh

  async getSshKeys(params: RR.GetSSHKeysReq): Promise<RR.GetSSHKeysRes> {
    return this.rpcRequest({ method: 'ssh.list', params })
  }

  async addSshKey(params: RR.AddSSHKeyReq): Promise<RR.AddSSHKeyRes> {
    return this.rpcRequest({ method: 'ssh.add', params })
  }

  async deleteSshKey(params: RR.DeleteSSHKeyReq): Promise<RR.DeleteSSHKeyRes> {
    return this.rpcRequest({ method: 'ssh.delete', params })
  }

  // backup

  async getBackupTargets(
    params: RR.GetBackupTargetsReq,
  ): Promise<RR.GetBackupTargetsRes> {
    return this.rpcRequest({ method: 'backup.target.list', params })
  }

  async addBackupTarget(
    type: BackupTargetType,
    params: RR.AddCifsBackupTargetReq | RR.AddCloudBackupTargetReq,
  ): Promise<RR.AddBackupTargetRes> {
    params.path = params.path.replace('/\\/g', '/')
    return this.rpcRequest({ method: `backup.target.${type}.add`, params })
  }

  async updateBackupTarget(
    type: BackupTargetType,
    params: RR.UpdateCifsBackupTargetReq | RR.UpdateCloudBackupTargetReq,
  ): Promise<RR.UpdateBackupTargetRes> {
    return this.rpcRequest({ method: `backup.target.${type}.update`, params })
  }

  async removeBackupTarget(
    params: RR.RemoveBackupTargetReq,
  ): Promise<RR.RemoveBackupTargetRes> {
    return this.rpcRequest({ method: 'backup.target.remove', params })
  }

  async getBackupJobs(
    params: RR.GetBackupJobsReq,
  ): Promise<RR.GetBackupJobsRes> {
    return this.rpcRequest({ method: 'backup.job.list', params })
  }

  async createBackupJob(
    params: RR.CreateBackupJobReq,
  ): Promise<RR.CreateBackupJobRes> {
    return this.rpcRequest({ method: 'backup.job.create', params })
  }

  async updateBackupJob(
    params: RR.UpdateBackupJobReq,
  ): Promise<RR.UpdateBackupJobRes> {
    return this.rpcRequest({ method: 'backup.job.update', params })
  }

  async deleteBackupJob(
    params: RR.DeleteBackupJobReq,
  ): Promise<RR.DeleteBackupJobRes> {
    return this.rpcRequest({ method: 'backup.job.delete', params })
  }

  async getBackupRuns(
    params: RR.GetBackupRunsReq,
  ): Promise<RR.GetBackupRunsRes> {
    return this.rpcRequest({ method: 'backup.runs.list', params })
  }

  async deleteBackupRuns(
    params: RR.DeleteBackupRunsReq,
  ): Promise<RR.DeleteBackupRunsRes> {
    return this.rpcRequest({ method: 'backup.runs.delete', params })
  }

  async getBackupInfo(
    params: RR.GetBackupInfoReq,
  ): Promise<RR.GetBackupInfoRes> {
    return this.rpcRequest({ method: 'backup.target.info', params })
  }

  async createBackup(params: RR.CreateBackupReq): Promise<RR.CreateBackupRes> {
    return this.rpcRequest({ method: 'backup.create', params })
  }

  // package

  async getPackageProperties(
    params: RR.GetPackagePropertiesReq,
  ): Promise<RR.GetPackagePropertiesRes> {
    return this.rpcRequest({ method: 'package.properties', params })
  }

  async getPackageLogs(
    params: RR.GetPackageLogsReq,
  ): Promise<RR.GetPackageLogsRes> {
    return this.rpcRequest({ method: 'package.logs', params })
  }

  async followPackageLogs(
    params: RR.FollowServerLogsReq,
  ): Promise<RR.FollowServerLogsRes> {
    return this.rpcRequest({ method: 'package.logs.follow', params })
  }

  async installPackage(
    params: RR.InstallPackageReq,
  ): Promise<RR.InstallPackageRes> {
    return this.rpcRequest({ method: 'package.install', params })
  }

  async getPackageConfig(
    params: RR.GetPackageConfigReq,
  ): Promise<RR.GetPackageConfigRes> {
    return this.rpcRequest({ method: 'package.config.get', params })
  }

  async drySetPackageConfig(
    params: RR.DrySetPackageConfigReq,
  ): Promise<RR.DrySetPackageConfigRes> {
    return this.rpcRequest({ method: 'package.config.set.dry', params })
  }

  async setPackageConfig(
    params: RR.SetPackageConfigReq,
  ): Promise<RR.SetPackageConfigRes> {
    return this.rpcRequest({ method: 'package.config.set', params })
  }

  async restorePackages(
    params: RR.RestorePackagesReq,
  ): Promise<RR.RestorePackagesRes> {
    return this.rpcRequest({ method: 'package.backup.restore', params })
  }

  async executePackageAction(
    params: RR.ExecutePackageActionReq,
  ): Promise<RR.ExecutePackageActionRes> {
    return this.rpcRequest({ method: 'package.action', params })
  }

  async startPackage(params: RR.StartPackageReq): Promise<RR.StartPackageRes> {
    return this.rpcRequest({ method: 'package.start', params })
  }

  async restartPackage(
    params: RR.RestartPackageReq,
  ): Promise<RR.RestartPackageRes> {
    return this.rpcRequest({ method: 'package.restart', params })
  }

  async stopPackage(params: RR.StopPackageReq): Promise<RR.StopPackageRes> {
    return this.rpcRequest({ method: 'package.stop', params })
  }

  async uninstallPackage(
    params: RR.UninstallPackageReq,
  ): Promise<RR.UninstallPackageRes> {
    return this.rpcRequest({ method: 'package.uninstall', params })
  }

  async dryConfigureDependency(
    params: RR.DryConfigureDependencyReq,
  ): Promise<RR.DryConfigureDependencyRes> {
    return this.rpcRequest({
      method: 'package.dependency.configure.dry',
      params,
    })
  }

  async sideloadPackage(
    params: RR.SideloadPackageReq,
  ): Promise<RR.SideloadPacakgeRes> {
    return this.rpcRequest({
      method: 'package.sideload',
      params,
    })
  }

  async setInterfaceClearnetAddress(
    params: RR.SetInterfaceClearnetAddressReq,
  ): Promise<RR.SetInterfaceClearnetAddressRes> {
    return this.rpcRequest({ method: 'package.interface.set-clearnet', params })
  }

  async setServiceOutboundProxy(
    params: RR.SetServiceOutboundProxyReq,
  ): Promise<RR.SetServiceOutboundProxyRes> {
    return this.rpcRequest({ method: 'package.proxy.set-outbound', params })
  }

  async getSetupStatus() {
    return this.rpcRequest<SetupStatus | null>({
      method: 'setup.status',
      params: {},
    })
  }

  private openWebsocket<T>(config: WebSocketSubjectConfig<T>): Observable<T> {
    const { location } = this.document.defaultView!
    const protocol = location.protocol === 'http:' ? 'ws' : 'wss'
    const host = location.host

    config.url = `${protocol}://${host}/ws${config.url}`

    return webSocket(config)
  }

  private async rpcRequest<T>(
    options: RPCOptions,
    urlOverride?: string,
  ): Promise<T> {
    const res = await this.http.rpcRequest<T>(options, urlOverride)
    const body = res.body

    if (isRpcError(body)) {
      if (body.error.code === 34) {
        console.error('Unauthenticated, logging out')
        this.auth.setUnverified()
      }
      throw new RpcError(body.error)
    }

    const patchSequence = res.headers.get('x-patch-sequence')
    if (patchSequence)
      await firstValueFrom(
        this.patch.cache$.pipe(
          filter(({ sequence }) => sequence >= Number(patchSequence)),
        ),
      )

    return body.result
  }

  private async httpRequest<T>(opts: HttpOptions): Promise<T> {
    const res = await this.http.httpRequest<T>(opts)
    return res.body
  }
}