@highstate/library 0.7.1 → 0.7.3

package/src/k8s.ts

@@ -0,0 +1,353 @@
+import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { providerEntity } from "./dns"
+
+export const clusterInfoSchema = Type.Object({
+  id: Type.String(),
+  name: Type.String(),
+  cni: Type.Optional(Type.String()),
+  externalIps: Type.Array(Type.String()),
+})
+
+export const serviceTypeSchema = Type.StringEnum(["NodePort", "LoadBalancer", "ClusterIP"])
+
+export const metadataSchema = Type.Object({
+  namespace: Type.Optional(Type.String()),
+  name: Type.String(),
+  labels: Type.Optional(Type.Record(Type.String(), Type.String())),
+  annotations: Type.Optional(Type.Record(Type.String(), Type.String())),
+})
+
+export const servicePortSchema = Type.Object({
+  name: Type.Optional(Type.String()),
+  port: Type.Optional(Type.Number()),
+  targetPort: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+  protocol: Type.Optional(Type.String()),
+})
+
+export const serviceSpecSchema = Type.Object({
+  type: Type.Optional(Type.String()),
+  selector: Type.Record(Type.String(), Type.String()),
+  ports: Type.Array(servicePortSchema),
+  clusterIP: Type.Optional(Type.String()),
+  clusterIPs: Type.Optional(Type.Array(Type.String())),
+  externalIPs: Type.Optional(Type.Array(Type.String())),
+})
+
+export const serviceEntity = defineEntity({
+  type: "k8s.service",
+
+  schema: Type.Object({
+    type: Type.Literal("k8s.service"),
+    clusterInfo: clusterInfoSchema,
+    metadata: metadataSchema,
+    spec: serviceSpecSchema,
+  }),
+
+  meta: {
+    color: "#2196F3",
+  },
+})
+
+export const clusterEntity = defineEntity({
+  type: "k8s.cluster",
+
+  schema: Type.Object({
+    info: clusterInfoSchema,
+    kubeconfig: Type.String(),
+  }),
+
+  meta: {
+    color: "#2196F3",
+  },
+})
+
+export const internalIpsPolicySchema = Type.StringEnum(["always", "public", "never"])
+
+export const existingCluster = defineUnit({
+  type: "k8s.existing-cluster",
+
+  args: {
+    /**
+     * The list of external IPs of the cluster nodes allowed to be used for external access.
+     *
+     * If not provided, will be automatically detected by querying the cluster nodes.
+     *
+     * @schema
+     */
+    externalIps: Type.Optional(Type.Array(Type.String())),
+
+    /**
+     * The policy for using internal IPs of the nodes as external IPs.
+     *
+     * - `always`: always use internal IPs as external IPs;
+     * - `public`: use internal IPs as external IPs only if they are (theoretically) routable from the public internet **(default)**;
+     * - `never`: never use internal IPs as external IPs.
+     *
+     * @schema
+     */
+    internalIpsPolicy: { ...internalIpsPolicySchema, default: "public" },
+
+    /**
+     * The FQDN to register the cluster nodes with.
+     *
+     * If provided and `registerFqdn` is set to `true`, the corresponding DNS provider must be provided to set up the DNS records.
+     *
+     * @schema
+     */
+    fqdn: Type.Optional(Type.String()),
+
+    /**
+     * Whether to register the cluster nodes with the provided FQDN.
+     *
+     * By default, `true`.
+     *
+     * @schema
+     */
+    registerFqdn: Type.Boolean({ default: true }),
+  },
+
+  secrets: {
+    /**
+     * The kubeconfig of the cluster to use for connecting to the cluster.
+     *
+     * Will be available for all components using `cluster` output of this unit.
+     *
+     * @schema
+     */
+    kubeconfig: Type.Record(Type.String(), Type.Any()),
+  },
+
+  outputs: {
+    cluster: clusterEntity,
+  },
+
+  meta: {
+    displayName: "Existing Cluster",
+    description: "An existing Kubernetes cluster.",
+    primaryIcon: "mdi:kubernetes",
+  },
+
+  source: {
+    package: "@highstate/k8s",
+    path: "existing-cluster",
+  },
+})
+
+export const gatewayEntity = defineEntity({
+  type: "k8s.gateway",
+
+  schema: Type.Object({
+    clusterInfo: clusterInfoSchema,
+    gatewayClassName: Type.String(),
+    httpListenerPort: Type.Number(),
+    httpsListenerPort: Type.Number(),
+    ip: Type.String(),
+    service: Type.Optional(serviceEntity.schema),
+  }),
+
+  meta: {
+    color: "#4CAF50",
+  },
+})
+
+export const tlsIssuerEntity = defineEntity({
+  type: "k8s.tls-issuer",
+
+  schema: Type.Object({
+    clusterInfo: clusterInfoSchema,
+    clusterIssuerName: Type.String(),
+  }),
+
+  meta: {
+    color: "#f06292",
+  },
+})
+
+export const accessPointEntity = defineEntity({
+  type: "common.access-point",
+  schema: Type.Object({
+    gateway: gatewayEntity.schema,
+    tlsIssuer: tlsIssuerEntity.schema,
+    dnsProvider: providerEntity.schema,
+  }),
+
+  meta: {
+    color: "#FFC107",
+  },
+})
+
+export const accessPoint = defineUnit({
+  type: "k8s.access-point",
+
+  inputs: {
+    gateway: gatewayEntity,
+    tlsIssuer: tlsIssuerEntity,
+    dnsProvider: providerEntity,
+  },
+
+  outputs: {
+    accessPoint: accessPointEntity,
+  },
+
+  meta: {
+    displayName: "Access Point",
+    description: "An access point which can be used to connect to services.",
+    primaryIcon: "mdi:access-point",
+  },
+
+  source: {
+    package: "@highstate/k8s",
+    path: "access-point",
+  },
+})
+
+export const certManager = defineUnit({
+  type: "k8s.cert-manager",
+
+  inputs: {
+    k8sCluster: clusterEntity,
+  },
+
+  outputs: {
+    k8sCluster: clusterEntity,
+  },
+
+  meta: {
+    displayName: "Cert Manager",
+    description: "A certificate manager for managing TLS certificates.",
+    primaryIcon: "simple-icons:letsencrypt",
+  },
+
+  source: {
+    package: "@highstate/k8s",
+    path: "cert-manager",
+  },
+})
+
+export const dns01TlsIssuer = defineUnit({
+  type: "k8s.dns01-issuer",
+
+  inputs: {
+    k8sCluster: clusterEntity,
+    dnsProvider: providerEntity,
+  },
+
+  outputs: {
+    tlsIssuer: tlsIssuerEntity,
+  },
+
+  meta: {
+    displayName: "DNS01 Issuer",
+    description: "A TLS issuer for issuing certificate using DNS01 challenge.",
+    primaryIcon: "mdi:certificate",
+  },
+
+  source: {
+    package: "@highstate/k8s",
+    path: "dns01-issuer",
+  },
+})
+
+export const containerSchema = Type.Object({
+  name: Type.String(),
+  image: Type.String(),
+})
+
+export const labelSelectorSchema = Type.Object({
+  matchLabels: Type.Record(Type.String(), Type.String()),
+})
+
+export const deploymentSpecSchema = Type.Object({
+  replicas: Type.Number(),
+  selector: labelSelectorSchema,
+  template: Type.Object({
+    metadata: metadataSchema,
+    spec: Type.Object({
+      containers: Type.Array(containerSchema),
+    }),
+  }),
+})
+
+export const deploymentEntity = defineEntity({
+  type: "k8s.deployment",
+
+  schema: Type.Object({
+    type: Type.Literal("k8s.deployment"),
+    clusterInfo: clusterInfoSchema,
+    metadata: metadataSchema,
+
+    service: Type.Optional(serviceEntity.schema),
+  }),
+
+  meta: {
+    color: "#4CAF50",
+  },
+})
+
+export const statefulSetEntity = defineEntity({
+  type: "k8s.stateful-set",
+
+  schema: Type.Object({
+    type: Type.Literal("k8s.stateful-set"),
+    clusterInfo: clusterInfoSchema,
+    metadata: metadataSchema,
+
+    service: Type.Optional(serviceEntity.schema),
+  }),
+
+  meta: {
+    color: "#FFC107",
+  },
+})
+
+export const persistentVolumeClaimEntity = defineEntity({
+  type: "k8s.persistent-volume-claim",
+
+  schema: Type.Object({
+    type: Type.Literal("k8s.persistent-volume-claim"),
+    clusterInfo: clusterInfoSchema,
+    metadata: metadataSchema,
+  }),
+
+  meta: {
+    color: "#FFC107",
+  },
+})
+
+export const interfaceEntity = defineEntity({
+  type: "k8s.interface",
+
+  schema: Type.Object({
+    name: Type.String(),
+    deployment: deploymentEntity.schema,
+  }),
+
+  meta: {
+    color: "#2196F3",
+    description:
+      "The interface in a network space of pod kernel which can accept or transmit packets.",
+  },
+})
+
+export type ClusterInfo = Static<typeof clusterInfoSchema>
+export type Cluster = Static<typeof clusterEntity.schema>
+
+export type Gateway = Static<typeof gatewayEntity.schema>
+export type TlsIssuer = Static<typeof tlsIssuerEntity.schema>
+export type AccessPoint = Static<typeof accessPointEntity.schema>
+
+export type Metadata = Static<typeof metadataSchema>
+
+export type ServiceType = Static<typeof serviceTypeSchema>
+export type ServicePort = Static<typeof servicePortSchema>
+export type ServiceSpec = Static<typeof serviceSpecSchema>
+export type Service = Static<typeof serviceEntity.schema>
+
+export type Container = Static<typeof containerSchema>
+export type DeploymentSpec = Static<typeof deploymentSpecSchema>
+export type Deployment = Static<typeof deploymentEntity.schema>
+
+export type PersistentVolumeClaim = Static<typeof persistentVolumeClaimEntity.schema>
+export type StatefulSet = Static<typeof statefulSetEntity.schema>
+
+export type Interface = Static<typeof interfaceEntity.schema>

package/src/mullvad.ts

@@ -0,0 +1,46 @@
+import { defineUnit, Type } from "@highstate/contract"
+import { networkEntity, peerEntity } from "./wireguard"
+
+export const endpointType = Type.Union([
+  Type.Literal("fqdn"),
+  Type.Literal("ipv4"),
+  Type.Literal("ipv6"),
+])
+
+export const peer = defineUnit({
+  type: "mullvad.peer",
+
+  args: {
+    hostname: Type.Optional(Type.String()),
+    endpointType: Type.Optional({ ...endpointType, default: "fqdn" }),
+  },
+
+  inputs: {
+    /**
+     * The network to use for the WireGuard peer.
+     *
+     * If not provided, the peer will use default network configuration.
+     */
+    network: {
+      entity: networkEntity,
+      required: false,
+    },
+  },
+
+  outputs: {
+    peer: peerEntity,
+  },
+
+  meta: {
+    displayName: "Mullvad Peer",
+    description: "The Mullvad WireGuard peer fetched from the Mullvad API.",
+    primaryIcon: "simple-icons:mullvad",
+    secondaryIcon: "cib:wireguard",
+    secondaryIconColor: "#88171a",
+  },
+
+  source: {
+    package: "@highstate/mullvad",
+    path: "peer",
+  },
+})

package/src/proxmox.ts

@@ -0,0 +1,188 @@
+import { defineEntity, defineUnit, Type } from "@highstate/contract"
+import { serverEntity } from "./common"
+import { keyPairEntity } from "./ssh"
+
+export const clusterEntity = defineEntity({
+  type: "proxmox.cluster",
+
+  schema: Type.Object({
+    endpoint: Type.String(),
+    insecure: Type.Optional(Type.Boolean()),
+    username: Type.Optional(Type.String()),
+
+    defaultNodeName: Type.String(),
+    defaultDatastoreId: Type.String(),
+
+    password: Type.Optional(Type.String()),
+    apiToken: Type.Optional(Type.String()),
+  }),
+
+  meta: {
+    color: "#e56901",
+  },
+})
+
+export const imageEntity = defineEntity({
+  type: "proxmox.image",
+
+  schema: Type.Object({
+    id: Type.String(),
+  }),
+
+  meta: {
+    color: "#e56901",
+  },
+})
+
+export const connection = defineUnit({
+  type: "proxmox.connection",
+
+  args: {
+    endpoint: Type.String(),
+    insecure: Type.Optional(Type.Boolean()),
+    username: Type.Optional(Type.String()),
+
+    defaultNodeName: Type.Optional(Type.String()),
+    defaultDatastoreId: Type.Optional(Type.String()),
+  },
+
+  secrets: {
+    password: Type.Optional(Type.String()),
+    apiToken: Type.Optional(Type.String()),
+  },
+
+  outputs: {
+    proxmoxCluster: clusterEntity,
+  },
+
+  meta: {
+    displayName: "Proxmox Connection",
+    description: "The connection to an existing Proxmox cluster.",
+    category: "Proxmox",
+    primaryIcon: "simple-icons:proxmox",
+    primaryIconColor: "#e56901",
+    secondaryIcon: "codicon:vm",
+  },
+
+  source: {
+    package: "@highstate/proxmox",
+    path: "connection",
+  },
+})
+
+export const image = defineUnit({
+  type: "proxmox.image",
+
+  args: {
+    url: Type.String(),
+    nodeName: Type.Optional(Type.String()),
+    sha256: Type.Optional(Type.String()),
+    datastoreId: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    proxmoxCluster: clusterEntity,
+  },
+
+  outputs: {
+    image: imageEntity,
+  },
+
+  meta: {
+    displayName: "Proxmox Image",
+    description: "The image to upload to a Proxmox cluster.",
+    category: "Proxmox",
+    primaryIcon: "simple-icons:proxmox",
+    primaryIconColor: "#e56901",
+    secondaryIcon: "mage:compact-disk-fill",
+  },
+
+  source: {
+    package: "@highstate/proxmox",
+    path: "image",
+  },
+})
+
+export const existingImage = defineUnit({
+  type: "proxmox.existing-image",
+
+  args: {
+    id: Type.String(),
+  },
+
+  outputs: {
+    image: imageEntity,
+  },
+
+  meta: {
+    displayName: "Proxmox Existing Image",
+    description: "The existing image on a Proxmox cluster.",
+    category: "Proxmox",
+    primaryIcon: "simple-icons:proxmox",
+    primaryIconColor: "#e56901",
+    secondaryIcon: "mage:compact-disk-fill",
+  },
+
+  source: {
+    package: "@highstate/proxmox",
+    path: "existing-image",
+  },
+})
+
+export const virtualMachine = defineUnit({
+  type: "proxmox.virtual-machine",
+
+  args: {
+    nodeName: Type.Optional(Type.String()),
+
+    cpuType: Type.Optional(Type.String({ default: "host" })),
+    cores: Type.Optional(Type.Number({ default: 1 })),
+    sockets: Type.Optional(Type.Number({ default: 1 })),
+    memory: Type.Optional(Type.Number({ default: 512 })),
+
+    ipv4: Type.Optional(Type.String()),
+    ipv4Gateway: Type.Optional(Type.String()),
+    dns: Type.Optional(Type.Array(Type.String())),
+
+    datastoreId: Type.Optional(Type.String()),
+    diskSize: Type.Optional(Type.Number({ default: 8 })),
+    bridge: Type.Optional(Type.String({ default: "vmbr0" })),
+
+    sshPort: Type.Optional(Type.Number({ default: 22 })),
+    sshUser: Type.Optional(Type.String({ default: "root" })),
+
+    waitForAgent: Type.Optional(Type.Boolean({ default: true })),
+  },
+
+  inputs: {
+    proxmoxCluster: clusterEntity,
+    image: imageEntity,
+
+    sshKeyPair: {
+      entity: keyPairEntity,
+      required: false,
+    },
+  },
+
+  secrets: {
+    sshPassword: Type.Optional(Type.String()),
+  },
+
+  outputs: {
+    server: serverEntity,
+  },
+
+  meta: {
+    displayName: "Proxmox Virtual Machine",
+    description: "The virtual machine on a Proxmox cluster.",
+    category: "Proxmox",
+    primaryIcon: "simple-icons:proxmox",
+    primaryIconColor: "#e56901",
+    secondaryIcon: "codicon:vm",
+  },
+
+  source: {
+    package: "@highstate/proxmox",
+    path: "virtual-machine",
+  },
+})

package/src/restic.ts

@@ -0,0 +1,51 @@
+import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+
+export const repoEntity = defineEntity({
+  type: "restic.repo",
+
+  schema: Type.Object({
+    password: Type.String(),
+    remoteDomains: Type.Array(Type.String()),
+
+    type: Type.Literal("rclone"),
+    rcloneConfig: Type.String(),
+    remoteName: Type.String(),
+    basePath: Type.String(),
+  }),
+
+  meta: {
+    color: "#e56901",
+  },
+})
+
+export const repo = defineUnit({
+  type: "restic.repo",
+
+  args: {
+    remoteDomains: Type.Optional(Type.Array(Type.String())),
+    basePath: Type.Optional(Type.String()),
+  },
+
+  secrets: {
+    password: Type.Optional(Type.String()),
+    rcloneConfig: Type.String({ multiline: true }),
+  },
+
+  outputs: {
+    repo: repoEntity,
+  },
+
+  meta: {
+    displayName: "Restic Repo",
+    description: "Holds the configuration for a Restic repository and its remote storage.",
+    primaryIconColor: "#e56901",
+    primaryIcon: "material-symbols:backup",
+  },
+
+  source: {
+    package: "@highstate/restic",
+    path: "repo",
+  },
+})
+
+export type Repo = Static<typeof repoEntity.schema>

package/src/ssh.ts

@@ -0,0 +1,60 @@
+import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+
+export const keyTypeSchema = Type.Union([
+  //
+  Type.Literal("rsa"),
+  Type.Literal("ed25519"),
+])
+
+export const keyPairEntity = defineEntity({
+  type: "ssh.key-pair",
+
+  schema: Type.Object({
+    type: keyTypeSchema,
+    privateKey: Type.String(),
+    publicKey: Type.String(),
+  }),
+
+  meta: {
+    color: "#2b5797",
+  },
+})
+
+export const credentialsSchema = Type.Object({
+  endpoint: Type.Optional(Type.String()),
+  user: Type.Optional(Type.String()),
+  port: Type.Optional(Type.Number()),
+  password: Type.Optional(Type.String()),
+  privateKey: Type.Optional(Type.String()),
+})
+
+export const keyPair = defineUnit({
+  type: "ssh.key-pair",
+
+  secrets: {
+    privateKey: Type.Optional(Type.String()),
+  },
+
+  outputs: {
+    keyPair: keyPairEntity,
+  },
+
+  meta: {
+    displayName: "SSH Key Pair",
+    description: "Holds the ED25519 SSH key pair and generates the private key if not provided.",
+    category: "ssh",
+    primaryIcon: "charm:key",
+    primaryIconColor: "#ffffff",
+    secondaryIcon: "mdi:lock",
+    secondaryIconColor: "#ffffff",
+  },
+
+  source: {
+    package: "@highstate/common",
+    path: "ssh/key-pair",
+  },
+})
+
+export type KeyType = Static<typeof keyTypeSchema>
+export type Credentials = Static<typeof credentialsSchema>
+export type KeyPair = Static<typeof keyPairEntity.schema>