@highstate/library 0.7.9 → 0.7.11

package/src/common.ts

@@ -66,5 +66,87 @@ export const existingServer = defineUnit({
   },
 })
 
+export const script = defineUnit({
+  type: "common.script",
+
+  args: {
+    script: Type.String({ language: "shell" }),
+    updateScript: Type.Optional(Type.String({ language: "shell" })),
+    deleteScript: Type.Optional(Type.String({ language: "shell" })),
+  },
+
+  inputs: {
+    server: serverEntity,
+  },
+
+  outputs: {
+    server: serverEntity,
+  },
+
+  meta: {
+    displayName: "Shell Script",
+    description: "Run a shell script on the server.",
+    primaryIcon: "mdi:bash",
+  },
+
+  source: {
+    package: "@highstate/common",
+    path: "script",
+  },
+})
+
+export const fileMetaEntity = defineEntity({
+  type: "common.file-meta",
+
+  schema: Type.Object({
+    name: Type.String(),
+    size: Type.Number(),
+    isBinary: Type.Optional(Type.Boolean()),
+    isExecutable: Type.Optional(Type.Boolean()),
+  }),
+
+  meta: {
+    color: "#FF5722",
+    description: "Metadata for a file.",
+  },
+})
+
+export const fileContentEntity = defineEntity({
+  type: "common.file-content",
+
+  schema: Type.Union([
+    Type.Object({
+      type: Type.Literal("inline"),
+      content: Type.String(),
+    }),
+    Type.Object({
+      type: Type.Literal("remote"),
+      url: Type.String(),
+    }),
+  ]),
+
+  meta: {
+    color: "#FF5722",
+    description: "The content of a file.",
+  },
+})
+
+export const fileEntity = defineEntity({
+  type: "common.file",
+
+  schema: Type.Object({
+    meta: fileMetaEntity.schema,
+    content: fileContentEntity.schema,
+  }),
+
+  meta: {
+    color: "#FF5722",
+  },
+})
+
 export type Server = Static<typeof serverEntity.schema>
 export type Endpoint = Static<typeof endpointEntity.schema>
+
+export type File = Static<typeof fileEntity.schema>
+export type FileMeta = Static<typeof fileMetaEntity.schema>
+export type FileContent = Static<typeof fileContentEntity.schema>

package/src/index.ts

@@ -11,3 +11,6 @@ export * as k3s from "./k3s"
 export * as restic from "./restic"
 export * as mullvad from "./mullvad"
 export * as dns from "./dns"
+export * as timeweb from "./timeweb"
+export * as nixos from "./nixos"
+export * as sops from "./sops"

package/src/k3s.ts

@@ -1,10 +1,14 @@
 import { defineUnit } from "@highstate/contract"
 import { serverEntity } from "./common"
-import { clusterEntity } from "./k8s"
+import { clusterEntity, sharedClusterArgs } from "./k8s"
 
 export const cluster = defineUnit({
   type: "k3s.cluster",
 
+  args: {
+    ...sharedClusterArgs,
+  },
+
   inputs: {
     server: serverEntity,
   },

package/src/k8s.ts

@@ -63,47 +63,51 @@ export const clusterEntity = defineEntity({
 
 export const internalIpsPolicySchema = Type.StringEnum(["always", "public", "never"])
 
+export const sharedClusterArgs = {
+  /**
+   * 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 }),
+}
+
 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 }),
+    ...sharedClusterArgs,
   },
 
   secrets: {
@@ -351,3 +355,4 @@ export type PersistentVolumeClaim = Static<typeof persistentVolumeClaimEntity.sc
 export type StatefulSet = Static<typeof statefulSetEntity.schema>
 
 export type Interface = Static<typeof interfaceEntity.schema>
+export type InternalIpsPolicy = Static<typeof internalIpsPolicySchema>

package/src/nixos.ts

@@ -0,0 +1,167 @@
+import { defineEntity, defineUnit, Type } from "@highstate/contract"
+import { fileEntity, serverEntity } from "./common"
+
+export const inlineModuleEntity = defineEntity({
+  type: "nixos.inline-module",
+
+  schema: Type.Object({
+    code: Type.String(),
+  }),
+
+  meta: {
+    displayName: "NixOS Inline Module",
+    description: "The NixOS module reference.",
+    color: "#5277c3",
+  },
+})
+
+export const inlineModule = defineUnit({
+  type: "nixos.inline-module",
+
+  args: {
+    code: Type.String({ language: "nix" }),
+  },
+
+  inputs: {
+    files: {
+      entity: fileEntity,
+      required: false,
+      multiple: true,
+    },
+  },
+
+  outputs: {
+    module: inlineModuleEntity,
+  },
+
+  meta: {
+    displayName: "NixOS Inline Module",
+    description: "Creates a NixOS module from inline code.",
+    primaryIcon: "simple-icons:nixos",
+    primaryIconColor: "#7ebae4",
+    secondaryIcon: "mdi:file-code",
+  },
+
+  source: {
+    package: "@highstate/nixos",
+    path: "inline-module",
+  },
+})
+
+export const flakeEntity = defineEntity({
+  type: "nixos.flake",
+
+  schema: Type.Object({
+    url: Type.String(),
+  }),
+
+  meta: {
+    displayName: "NixOS Flake",
+    description: "The NixOS flake reference.",
+    color: "#5277c3",
+  },
+})
+
+export const remoteFlake = defineUnit({
+  type: "nixos.remote-flake",
+
+  args: {
+    url: Type.String(),
+  },
+
+  outputs: {
+    flake: flakeEntity,
+  },
+
+  meta: {
+    displayName: "NixOS Remote Flake",
+    description: "References a remote NixOS flake.",
+    primaryIcon: "simple-icons:nixos",
+    primaryIconColor: "#7ebae4",
+    secondaryIcon: "simple-icons:git",
+    secondaryIconColor: "#f1502f",
+  },
+
+  source: {
+    package: "@highstate/nixos",
+    path: "flake",
+  },
+})
+
+export const inlineFlake = defineUnit({
+  type: "nixos.inline-flake",
+
+  args: {
+    code: Type.String({ language: "nix" }),
+  },
+
+  inputs: {
+    flakes: {
+      entity: flakeEntity,
+      required: false,
+      multiple: true,
+    },
+    modules: {
+      entity: inlineModuleEntity,
+      required: false,
+      multiple: true,
+    },
+    files: {
+      entity: fileEntity,
+      required: false,
+      multiple: true,
+    },
+  },
+
+  outputs: {
+    flake: flakeEntity,
+  },
+
+  meta: {
+    displayName: "NixOS Inline Flake",
+    description: "Creates a NixOS flake from inline code.",
+    primaryIcon: "simple-icons:nixos",
+    primaryIconColor: "#7ebae4",
+    secondaryIcon: "mdi:file-code",
+  },
+
+  source: {
+    package: "@highstate/nixos",
+    path: "inline-flake",
+  },
+})
+
+export const system = defineUnit({
+  type: "nixos.system",
+
+  args: {
+    system: Type.Optional(Type.String()),
+  },
+
+  inputs: {
+    flake: flakeEntity,
+    server: serverEntity,
+    modules: {
+      entity: inlineModuleEntity,
+      required: false,
+      multiple: true,
+    },
+  },
+
+  outputs: {
+    server: serverEntity,
+  },
+
+  meta: {
+    displayName: "NixOS System",
+    description: "Creates a NixOS system on top of any server.",
+    primaryIcon: "simple-icons:nixos",
+    primaryIconColor: "#7ebae4",
+    secondaryIcon: "codicon:vm",
+  },
+
+  source: {
+    package: "@highstate/nixos",
+    path: "system",
+  },
+})

package/src/sops.ts

@@ -0,0 +1,33 @@
+import { defineUnit, Type } from "@highstate/contract"
+import { fileEntity, serverEntity } from "./common"
+
+export const secrets = defineUnit({
+  type: "sops.secrets",
+
+  args: {
+    secrets: Type.Record(Type.String(), Type.Any()),
+  },
+
+  inputs: {
+    servers: {
+      entity: serverEntity,
+      required: false,
+      multiple: true,
+    },
+  },
+
+  outputs: {
+    file: fileEntity,
+  },
+
+  meta: {
+    displayName: "SOPS Secrets",
+    description: "Encrypts secrets using SOPS for the specified servers.",
+    primaryIcon: "mdi:file-lock",
+  },
+
+  source: {
+    package: "@highstate/sops",
+    path: "secrets",
+  },
+})

package/src/timeweb.ts

@@ -0,0 +1,73 @@
+import { defineEntity, defineUnit, Type } from "@highstate/contract"
+import { serverEntity } from "./common"
+import { keyPairEntity } from "./ssh"
+
+export const connectionEntity = defineEntity({
+  type: "timeweb.connection",
+
+  schema: Type.Object({
+    name: Type.String(),
+    apiToken: Type.String(),
+  }),
+})
+
+export const connection = defineUnit({
+  type: "timeweb.connection",
+
+  secrets: {
+    apiToken: Type.String(),
+  },
+
+  outputs: {
+    connection: connectionEntity,
+  },
+
+  meta: {
+    displayName: "Timeweb Connection",
+    description: "Creates a new Timeweb connection.",
+    primaryIcon: "material-symbols:cloud",
+  },
+
+  source: {
+    package: "@highstate/timeweb",
+    path: "connection",
+  },
+})
+
+export const virtualMachine = defineUnit({
+  type: "timeweb.virtual-machine",
+
+  args: {
+    presetId: Type.Optional(Type.Number()),
+    osId: Type.Optional(Type.Number()),
+    availabilityZone: Type.String(),
+  },
+
+  inputs: {
+    connection: connectionEntity,
+    sshKeyPair: {
+      entity: keyPairEntity,
+      required: false,
+    },
+  },
+
+  secrets: {
+    sshPrivateKey: Type.Optional(Type.String()),
+  },
+
+  outputs: {
+    server: serverEntity,
+  },
+
+  meta: {
+    displayName: "Timeweb Virtual Machine",
+    description: "Creates a new Timeweb virtual machine.",
+    primaryIcon: "material-symbols:cloud",
+    secondaryIcon: "codicon:vm",
+  },
+
+  source: {
+    package: "@highstate/timeweb",
+    path: "virtual-machine",
+  },
+})