Refactor/actions (#2733)

* store, properties, manifest

* interfaces

* init and backups

* fix init and backups

* file models

* more versions

* dependencies

* config except dynamic types

* clean up config

* remove disabled from non-dynamic vaues

* actions

* standardize example code block formats

* wip: actions refactor

Co-authored-by: Jade <Blu-J@users.noreply.github.com>

* commit types

* fix types

* update types

* update action request type

* update apis

* add description to actionrequest

* clean up imports

* revert package json

* chore: Remove the recursive to the index

* chore: Remove the other thing I was testing

* flatten action requests

* update container runtime with new config paradigm

* new actions strategy

* seems to be working

* misc backend fixes

* fix fe bugs

* only show breakages if breakages

* only show success modal if result

* don't panic on failed removal

* hide config from actions page

* polyfill autoconfig

* use metadata strategy for actions instead of prev

* misc fixes

* chore: split the sdk into 2 libs (#2736)

* follow sideload progress (#2718)

* follow sideload progress

* small bugfix

* shareReplay with no refcount false

* don't wrap sideload progress in RPCResult

* dont present toast

---------

Co-authored-by: Aiden McClelland <me@drbonez.dev>

* chore: Add the initial of the creation of the two sdk

* chore: Add in the baseDist

* chore: Add in the baseDist

* chore: Get the web and the runtime-container running

* chore: Remove the empty file

* chore: Fix it so the container-runtime works

---------

Co-authored-by: Matt Hill <MattDHill@users.noreply.github.com>
Co-authored-by: Aiden McClelland <me@drbonez.dev>

* misc fixes

* update todos

* minor clean up

* fix link script

* update node version in CI test

* fix node version syntax in ci build

* wip: fixing callbacks

* fix sdk makefile dependencies

* add support for const outside of main

* update apis

* don't panic!

* Chore: Capture weird case on rpc, and log that

* fix procedure id issue

* pass input value for dep auto config

* handle disabled and warning for actions

* chore: Fix for link not having node_modules

* sdk fixes

* fix build

* fix build

* fix build

---------

Co-authored-by: Matt Hill <mattnine@protonmail.com>
Co-authored-by: Jade <Blu-J@users.noreply.github.com>
Co-authored-by: J H <dragondef@gmail.com>
Co-authored-by: Jade <2364004+Blu-J@users.noreply.github.com>
Co-authored-by: Matt Hill <MattDHill@users.noreply.github.com>

sdk/base/lib/interfaces/AddressReceipt.ts

@@ -0,0 +1,4 @@
+declare const AddressProof: unique symbol
+export type AddressReceipt = {
+  [AddressProof]: never
+}

sdk/base/lib/interfaces/Host.ts

@@ -0,0 +1,210 @@
+import { object, string } from "ts-matches"
+import { Effects } from "../Effects"
+import { Origin } from "./Origin"
+import { AddSslOptions, BindParams } from "../osBindings"
+import { Security } from "../osBindings"
+import { BindOptions } from "../osBindings"
+import { AlpnInfo } from "../osBindings"
+
+export { AddSslOptions, Security, BindOptions }
+
+export const knownProtocols = {
+  http: {
+    secure: null,
+    defaultPort: 80,
+    withSsl: "https",
+    alpn: { specified: ["http/1.1"] } as AlpnInfo,
+  },
+  https: {
+    secure: { ssl: true },
+    defaultPort: 443,
+  },
+  ws: {
+    secure: null,
+    defaultPort: 80,
+    withSsl: "wss",
+    alpn: { specified: ["http/1.1"] } as AlpnInfo,
+  },
+  wss: {
+    secure: { ssl: true },
+    defaultPort: 443,
+  },
+  ssh: {
+    secure: { ssl: false },
+    defaultPort: 22,
+  },
+  bitcoin: {
+    secure: { ssl: false },
+    defaultPort: 8333,
+  },
+  lightning: {
+    secure: { ssl: true },
+    defaultPort: 9735,
+  },
+  grpc: {
+    secure: { ssl: true },
+    defaultPort: 50051,
+  },
+  dns: {
+    secure: { ssl: false },
+    defaultPort: 53,
+  },
+} as const
+
+export type Scheme = string | null
+
+type KnownProtocols = typeof knownProtocols
+type ProtocolsWithSslVariants = {
+  [K in keyof KnownProtocols]: KnownProtocols[K] extends {
+    withSsl: string
+  }
+    ? K
+    : never
+}[keyof KnownProtocols]
+type NotProtocolsWithSslVariants = Exclude<
+  keyof KnownProtocols,
+  ProtocolsWithSslVariants
+>
+
+type BindOptionsByKnownProtocol =
+  | {
+      protocol: ProtocolsWithSslVariants
+      preferredExternalPort?: number
+      addSsl?: Partial<AddSslOptions>
+    }
+  | {
+      protocol: NotProtocolsWithSslVariants
+      preferredExternalPort?: number
+      addSsl?: AddSslOptions
+    }
+export type BindOptionsByProtocol = BindOptionsByKnownProtocol | BindOptions
+
+export type HostKind = BindParams["kind"]
+
+const hasStringProtocol = object({
+  protocol: string,
+}).test
+
+export class Host {
+  constructor(
+    readonly options: {
+      effects: Effects
+      kind: HostKind
+      id: string
+    },
+  ) {}
+
+  /**
+   * @description Use this function to bind the host to an internal port and configured options for protocol, security, and external port.
+   *
+   * @param internalPort - The internal port to be bound.
+   * @param options - The protocol options for this binding.
+   * @returns A multi-origin that is capable of exporting one or more service interfaces.
+   * @example
+   * In this example, we bind a previously created multi-host to port 80, then select the http protocol and request an external port of 8332.
+   *
+   * ```
+    const uiMultiOrigin = await uiMulti.bindPort(80, {
+      protocol: 'http',
+      preferredExternalPort: 8332,
+    })
+   * ```
+   */
+  async bindPort(
+    internalPort: number,
+    options: BindOptionsByProtocol,
+  ): Promise<Origin<this>> {
+    if (hasStringProtocol(options)) {
+      return await this.bindPortForKnown(options, internalPort)
+    } else {
+      return await this.bindPortForUnknown(internalPort, options)
+    }
+  }
+
+  private async bindPortForUnknown(
+    internalPort: number,
+    options: {
+      preferredExternalPort: number
+      addSsl: AddSslOptions | null
+      secure: { ssl: boolean } | null
+    },
+  ) {
+    const binderOptions = {
+      kind: this.options.kind,
+      id: this.options.id,
+      internalPort,
+      ...options,
+    }
+    await this.options.effects.bind(binderOptions)
+
+    return new Origin(this, internalPort, null, null)
+  }
+
+  private async bindPortForKnown(
+    options: BindOptionsByKnownProtocol,
+    internalPort: number,
+  ) {
+    const protoInfo = knownProtocols[options.protocol]
+    const preferredExternalPort =
+      options.preferredExternalPort ||
+      knownProtocols[options.protocol].defaultPort
+    const sslProto = this.getSslProto(options, protoInfo)
+    const addSsl =
+      sslProto && "alpn" in protoInfo
+        ? {
+            // addXForwardedHeaders: null,
+            preferredExternalPort: knownProtocols[sslProto].defaultPort,
+            scheme: sslProto,
+            alpn: protoInfo.alpn,
+            ...("addSsl" in options ? options.addSsl : null),
+          }
+        : null
+
+    const secure: Security | null = !protoInfo.secure ? null : { ssl: false }
+
+    await this.options.effects.bind({
+      kind: this.options.kind,
+      id: this.options.id,
+      internalPort,
+      preferredExternalPort,
+      addSsl,
+      secure,
+    })
+
+    return new Origin(this, internalPort, options.protocol, sslProto)
+  }
+
+  private getSslProto(
+    options: BindOptionsByKnownProtocol,
+    protoInfo: KnownProtocols[keyof KnownProtocols],
+  ) {
+    if (inObject("noAddSsl", options) && options.noAddSsl) return null
+    if ("withSsl" in protoInfo && protoInfo.withSsl) return protoInfo.withSsl
+    return null
+  }
+}
+
+function inObject<Key extends string>(
+  key: Key,
+  obj: any,
+): obj is { [K in Key]: unknown } {
+  return key in obj
+}
+
+// export class StaticHost extends Host {
+//   constructor(options: { effects: Effects; id: string }) {
+//     super({ ...options, kind: "static" })
+//   }
+// }
+
+// export class SingleHost extends Host {
+//   constructor(options: { effects: Effects; id: string }) {
+//     super({ ...options, kind: "single" })
+//   }
+// }
+
+export class MultiHost extends Host {
+  constructor(options: { effects: Effects; id: string }) {
+    super({ ...options, kind: "multi" })
+  }
+}

sdk/base/lib/interfaces/Origin.ts

@@ -0,0 +1,88 @@
+import { AddressInfo } from "../types"
+import { AddressReceipt } from "./AddressReceipt"
+import { Host, Scheme } from "./Host"
+import { ServiceInterfaceBuilder } from "./ServiceInterfaceBuilder"
+
+export class Origin<T extends Host> {
+  constructor(
+    readonly host: T,
+    readonly internalPort: number,
+    readonly scheme: string | null,
+    readonly sslScheme: string | null,
+  ) {}
+
+  build({ username, path, search, schemeOverride }: BuildOptions): AddressInfo {
+    const qpEntries = Object.entries(search)
+      .map(
+        ([key, val]) => `${encodeURIComponent(key)}=${encodeURIComponent(val)}`,
+      )
+      .join("&")
+
+    const qp = qpEntries.length ? `?${qpEntries}` : ""
+
+    return {
+      hostId: this.host.options.id,
+      internalPort: this.internalPort,
+      scheme: schemeOverride ? schemeOverride.noSsl : this.scheme,
+      sslScheme: schemeOverride ? schemeOverride.ssl : this.sslScheme,
+      suffix: `${path}${qp}`,
+      username,
+    }
+  }
+
+  /**
+   * @description A function to register a group of origins (<PROTOCOL> :// <HOSTNAME> : <PORT>) with StartOS
+   *
+   *   The returned addressReceipt serves as proof that the addresses were registered
+   *
+   * @param addressInfo
+   * @returns
+   */
+  async export(
+    serviceInterfaces: ServiceInterfaceBuilder[],
+  ): Promise<AddressInfo[] & AddressReceipt> {
+    const addressesInfo = []
+    for (let serviceInterface of serviceInterfaces) {
+      const {
+        name,
+        description,
+        hasPrimary,
+        id,
+        type,
+        username,
+        path,
+        search,
+        schemeOverride,
+        masked,
+      } = serviceInterface.options
+
+      const addressInfo = this.build({
+        username,
+        path,
+        search,
+        schemeOverride,
+      })
+
+      await serviceInterface.options.effects.exportServiceInterface({
+        id,
+        name,
+        description,
+        hasPrimary,
+        addressInfo,
+        type,
+        masked,
+      })
+
+      addressesInfo.push(addressInfo)
+    }
+
+    return addressesInfo as AddressInfo[] & AddressReceipt
+  }
+}
+
+type BuildOptions = {
+  schemeOverride: { ssl: Scheme; noSsl: Scheme } | null
+  username: string | null
+  path: string
+  search: Record<string, string>
+}

sdk/base/lib/interfaces/ServiceInterfaceBuilder.ts

@@ -0,0 +1,32 @@
+import { ServiceInterfaceType } from "../types"
+import { Effects } from "../Effects"
+import { Scheme } from "./Host"
+
+/**
+ * A helper class for creating a Network Interface
+ *
+ * Network Interfaces are collections of web addresses that expose the same API or other resource,
+ * display to the user with under a common name and description.
+ *
+ * All URIs on an interface inherit the same ui: bool, basic auth credentials, path, and search (query) params
+ *
+ * @param options
+ * @returns
+ */
+export class ServiceInterfaceBuilder {
+  constructor(
+    readonly options: {
+      effects: Effects
+      name: string
+      id: string
+      description: string
+      hasPrimary: boolean
+      type: ServiceInterfaceType
+      username: string | null
+      path: string
+      search: Record<string, string>
+      schemeOverride: { ssl: Scheme; noSsl: Scheme } | null
+      masked: boolean
+    },
+  ) {}
+}

sdk/base/lib/interfaces/interfaceReceipt.ts

@@ -0,0 +1,4 @@
+declare const InterfaceProof: unique symbol
+export type InterfaceReceipt = {
+  [InterfaceProof]: never
+}

sdk/base/lib/interfaces/setupInterfaces.ts

@@ -0,0 +1,54 @@
+import * as T from "../types"
+import { AddressReceipt } from "./AddressReceipt"
+
+declare const UpdateServiceInterfacesProof: unique symbol
+export type UpdateServiceInterfacesReceipt = {
+  [UpdateServiceInterfacesProof]: never
+}
+
+export type ServiceInterfacesReceipt = Array<T.AddressInfo[] & AddressReceipt>
+export type SetServiceInterfaces<Output extends ServiceInterfacesReceipt> =
+  (opts: { effects: T.Effects }) => Promise<Output>
+export type UpdateServiceInterfaces<Output extends ServiceInterfacesReceipt> =
+  (opts: {
+    effects: T.Effects
+  }) => Promise<Output & UpdateServiceInterfacesReceipt>
+export type SetupServiceInterfaces = <Output extends ServiceInterfacesReceipt>(
+  fn: SetServiceInterfaces<Output>,
+) => UpdateServiceInterfaces<Output>
+export const NO_INTERFACE_CHANGES = {} as UpdateServiceInterfacesReceipt
+export const setupServiceInterfaces: SetupServiceInterfaces = <
+  Output extends ServiceInterfacesReceipt,
+>(
+  fn: SetServiceInterfaces<Output>,
+) =>
+  ((options: { effects: T.Effects }) => {
+    const updater = async (options: { effects: T.Effects }) => {
+      const bindings: T.BindId[] = []
+      const interfaces: T.ServiceInterfaceId[] = []
+      const res = await fn({
+        effects: {
+          ...options.effects,
+          bind: (params: T.BindParams) => {
+            bindings.push({ id: params.id, internalPort: params.internalPort })
+            return options.effects.bind(params)
+          },
+          exportServiceInterface: (params: T.ExportServiceInterfaceParams) => {
+            interfaces.push(params.id)
+            return options.effects.exportServiceInterface(params)
+          },
+        },
+      })
+      await options.effects.clearBindings({ except: bindings })
+      await options.effects.clearServiceInterfaces({ except: interfaces })
+      return res
+    }
+    const updaterCtx = { options }
+    updaterCtx.options = {
+      effects: {
+        ...options.effects,
+        constRetry: () => updater(updaterCtx.options),
+      },
+    }
+    return updater(updaterCtx.options)
+  }) as UpdateServiceInterfaces<Output>