rename frontend to web

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

@@ -0,0 +1,600 @@
+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)
+  }
+
+  async followLogs(): Promise<string> {
+    return this.rpcRequest({ method: 'setup.logs.follow', params: {} })
+  }
+
+  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 = {
+      'marketplace-url': 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 toggleZram(params: RR.ToggleZramReq): Promise<RR.ToggleZramRes> {
+    return this.rpcRequest({ method: 'server.experimental.zram', 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 = { 'server-id': 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 deleteNotification(
+    params: RR.DeleteNotificationReq,
+  ): Promise<RR.DeleteNotificationRes> {
+    return this.rpcRequest({ method: 'notification.delete', params })
+  }
+
+  async deleteAllNotifications(
+    params: RR.DeleteAllNotificationsReq,
+  ): Promise<RR.DeleteAllNotificationsRes> {
+    return this.rpcRequest({
+      method: 'notification.delete-before',
+      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 getPackageCredentials(
+    params: RR.GetPackageCredentialsReq,
+  ): Promise<RR.GetPackageCredentialsRes> {
+    return this.rpcRequest({ method: 'package.credentials', 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
+  }
+}