Merge branch 'main' into flyio

.github/workflows/ci.yaml

@@ -0,0 +1,31 @@
+name: ci
+
+on:
+  push:
+    branches:
+      - main
+
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+      - run: bun test
+  fmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+      - run: bun fmt:ci

.gitignore

@@ -1 +1,4 @@
 .terraform*
+node_modules
+*.tfstate
+*.tfstate.lock.info

.sample/run.sh

@@ -1,17 +1,18 @@
 #!/usr/bin/env sh
 
-echo "Instalalting ${MODULE_NAME}..."
+BOLD='\033[0;1m'
+echo "$${BOLD}Installing MODULE_NAME..."
 # Add code here
 # Use varibles from the templatefile function in main.tf
 # e.g. LOG_PATH, PORT, etc.
 
-echo "Installation comlete!"
+echo "🥳 Installation comlete!"
 
-echo "Starting ${MODULE_NAME}..."
+echo "👷 Starting MODULE_NAME in background..."
 # Start the app in here
 # 1. Use & to run it in background
 # 2. redirct stdout and stderr to log files
 
 ./app >${LOG_PATH} 2>&1 &
 
-echo "Sample app started!"
+echo "check logs at ${LOG_PATH}"

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "files.exclude": {
+    "**/terraform.tfstate": true,
+    "**/.terraform": true
+  }
+}

CONTRIBUTING.md

@@ -6,37 +6,21 @@ To create a new module, clone this repository and run:
 ./new.sh MOUDLE_NAME
 ```
 
-Test a module by running an instance of Coder on your local machine:
-
-```shell
-coder server --in-memory
-```
-
-This will create a new module in the modules directory with the given name and scaffolding.
-Edit the files, adding your module's implementation, documentation and screenshots.
-
 ## Testing a Module
 
-Create a template and edit it to include your development module:
+A suite of test-helpers exists to run `terraform apply` on modules with variables, and test script output against containers.
 
-> [!NOTE]
+Reference existing `*.test.ts` files for implementation.
-> The Docker starter template is recommended for quick-iteration!
 
-```hcl
+```shell
-module "MOUDLE_NAME" {
+# Run tests for a specific module!
-    source = "/home/user/coder/modules/MOUDLE_NAME"
+$ bun test -t '<module>'
-}
 ```
 
-You can also test your module by specifying the source as a git repository:
+You can test a module locally by updating the source as follows
 
 ```hcl
-module "MOUDLE_NAME" {
+source = "git::https://github.com/<USERNAME>/<REPO>.git//<MODULE-NAME>?ref=<BRANCH-NAME>"
-    source = "git::https://github.com/<USERNAME>/<REPO>.git//<FOLDER>?ref=<BRANCH>"
-}
 ```
 
-Build a workspace and your module will be consumed! 🥳
+> **Note:** This is the responsibility of the module author to implement tests for their module. and test the module locally before submitting a PR.
-
-Open a pull-request with your module, a member of the Coder team will
-manually test it, and after-merge it will appear on the Registry.

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

aws-region/main.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "bun:test";
+import {
+  executeScriptInContainer,
+  runTerraformApply,
+  runTerraformInit,
+  testRequiredVariables,
+} from "../test";
+
+describe("aws-region", async () => {
+  await runTerraformInit(import.meta.dir);
+
+  testRequiredVariables(import.meta.dir, {});
+
+  it("default output", async () => {
+    const state = await runTerraformApply(import.meta.dir, {});
+    expect(state.outputs.value.value).toBe("us-east-1");
+  });
+
+  it("customized default", async () => {
+    const state = await runTerraformApply(import.meta.dir, {
+      default: "us-west-2",
+    });
+    expect(state.outputs.value.value).toBe("us-west-2");
+  });
+});

azure-region/main.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "bun:test";
+import {
+  executeScriptInContainer,
+  runTerraformApply,
+  runTerraformInit,
+  testRequiredVariables,
+} from "../test";
+
+describe("azure-region", async () => {
+  await runTerraformInit(import.meta.dir);
+
+  testRequiredVariables(import.meta.dir, {});
+
+  it("default output", async () => {
+    const state = await runTerraformApply(import.meta.dir, {});
+    expect(state.outputs.value.value).toBe("eastus");
+  });
+
+  it("customized default", async () => {
+    const state = await runTerraformApply(import.meta.dir, {
+      default: "westus",
+    });
+    expect(state.outputs.value.value).toBe("westus");
+  });
+});

bunfig.toml

@@ -0,0 +1,2 @@
+[test]
+preload = ["./setup.ts"]

code-server/main.tf

@@ -17,7 +17,7 @@ variable "agent_id" {
 variable "extensions" {
   type        = list(string)
   description = "A list of extensions to install."
-    default = [ ]
+  default     = []
 }
 
 variable "port" {
@@ -55,12 +55,12 @@ resource "coder_script" "code-server" {
   display_name = "code-server"
   icon         = "/icon/code.svg"
   script = templatefile("${path.module}/run.sh", {
-      EXTENSIONS: join(",", var.extensions),
+    EXTENSIONS : join(",", var.extensions),
-      PORT: var.port,
+    PORT : var.port,
-      LOG_PATH: var.log_path,
+    LOG_PATH : var.log_path,
-      INSTALL_PREFIX: var.install_prefix,
+    INSTALL_PREFIX : var.install_prefix,
     // This is necessary otherwise the quotes are stripped!
-      SETTINGS: replace(jsonencode(var.settings), "\"", "\\\""),
+    SETTINGS : replace(jsonencode(var.settings), "\"", "\\\""),
   })
   run_on_start = true
 }

dotfiles/README.md

@@ -10,3 +10,10 @@ tags: [helper]
 # Dotfiles
 
 Allow developers to optionally bring their own [dotfiles repository](https://dotfiles.github.io)! Under the hood, this module uses the [coder dotfiles](https://coder.com/docs/v2/latest/dotfiles) command.
+
+```hcl
+module "dotfiles" {
+  source = "https://registry.coder.com/modules/dotfiles"
+  agent_id = coder_agent.example.id
+}
+```

dotfiles/main.tf

@@ -16,11 +16,12 @@ variable "agent_id" {
 
 data "coder_parameter" "dotfiles_uri" {
   type         = "string"
+  name         = "dotfiles_uri"
   display_name = "Dotfiles URL (optional)"
   default      = ""
   description  = "Enter a URL for a [dotfiles repository](https://dotfiles.github.io) to personalize your workspace"
   mutable      = true
-  icon         = "https://raw.githubusercontent.com/jglovier/dotfiles-logo/main/dotfiles-logo-icon.svg"
+  icon         = "/icon/dotfiles.svg"
 }
 
 resource "coder_script" "personalize" {
@@ -32,6 +33,6 @@ resource "coder_script" "personalize" {
     fi
     EOT
   display_name = "Dotfiles"
-  icon         = "https://raw.githubusercontent.com/jglovier/dotfiles-logo/main/dotfiles-logo-icon.svg"
+  icon         = "/icon/dotfiles.svg"
   run_on_start = true
 }

fly-region/README.md

@@ -13,6 +13,7 @@ This module adds Fly.io regions to your Coder template. Regions can be whitelist
 
 ## Examples
 
+
 ### Using default settings
 
 We can use the simplest format here, only adding a default selection as the `atl` region.
@@ -62,3 +63,4 @@ module "fly-region" {
 ## Associated template
 
 For a pre-configured Fly.io template, see the Coder template registry.
+

gcp-region/README.md

@@ -6,6 +6,7 @@ maintainer_github: coder
 verified: true
 tags: [gcp, regions, parameter, helper]
 ---
+
 # Google Cloud Platform Regions
 
 This module adds Google Cloud Platform regions to your Coder template.

git-clone/README.md

@@ -6,6 +6,7 @@ maintainer_github: coder
 verified: true
 tags: [git, helper]
 ---
+
 # Git Clone
 
 This module allows you to automatically clone a repository by URL and skip if it exists in the path provided.

git-clone/main.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "bun:test";
+import {
+  executeScriptInContainer,
+  runTerraformApply,
+  runTerraformInit,
+  testRequiredVariables,
+} from "../test";
+
+describe("git-clone", async () => {
+  await runTerraformInit(import.meta.dir);
+
+  testRequiredVariables(import.meta.dir, {
+    agent_id: "foo",
+    url: "foo",
+  });
+
+  it("fails without git", async () => {
+    const state = await runTerraformApply(import.meta.dir, {
+      agent_id: "foo",
+      url: "some-url",
+    });
+    const output = await executeScriptInContainer(state, "alpine");
+    expect(output.exitCode).toBe(1);
+    expect(output.stdout).toEqual(["Git is not installed!"]);
+  });
+
+  it("runs with git", async () => {
+    const state = await runTerraformApply(import.meta.dir, {
+      agent_id: "foo",
+      url: "fake-url",
+    });
+    const output = await executeScriptInContainer(state, "alpine/git");
+    expect(output.exitCode).toBe(128);
+    expect(output.stdout).toEqual([
+      "Creating directory ~/fake-url...",
+      "Cloning fake-url to ~/fake-url...",
+    ]);
+  });
+});

git-clone/main.tf

@@ -30,8 +30,8 @@ resource "coder_script" "git_clone" {
   display_name = "Git Clone"
   icon         = "/icons/git.svg"
   script = templatefile("${path.module}/run.sh", {
-      CLONE_PATH: var.path != "" ? var.path : join("/", ["~", basename(var.url)]),
+    CLONE_PATH : var.path != "" ? var.path : join("/", ["~", basename(var.url)]),
-      REPO_URL: var.url,
+    REPO_URL : var.url,
   })
   run_on_start = true
 }

jetbrains-gateway/README.md

@@ -6,6 +6,7 @@ maintainer_github: coder
 verified: true
 tags: [ide, jetbrains, helper, parameter]
 ---
+
 # JetBrains Gateway
 
 This module adds a JetBrains Gateway Button to open any workspace with a single click.

jupyterlab/README.md

@@ -11,7 +11,7 @@ tags: [jupyter, helper, ide, web]
 
 A module that adds JupyterLab in your Coder template.
 
-![JupyterLab](../.images/jupyterlab.webp)
+![JupyterLab](../.images/jupyterlab.png)
 
 ```hcl
 module "jupyterlab" {

jupyterlab/main.tf

@@ -9,10 +9,6 @@ terraform {
   }
 }
 
-locals {
-  icon_url = "/icon/jupyter.svg"
-}
-
 # Add required variables for your modules and remove any unneeded variables
 variable "agent_id" {
   type        = string
@@ -34,13 +30,12 @@ variable "port" {
 resource "coder_script" "jupyterlab" {
   agent_id     = var.agent_id
   display_name = "jupyterlab"
-  icon         = local.icon_url
+  icon         = "/icon/jupyter.svg"
   script = templatefile("${path.module}/run.sh", {
     LOG_PATH : var.log_path,
     PORT : var.port
   })
   run_on_start = true
-  run_on_stopt = false
 }
 
 resource "coder_app" "jupyterlab" {
@@ -48,7 +43,7 @@ resource "coder_app" "jupyterlab" {
   slug         = "jupyterlab"
   display_name = "JupyterLab"
   url          = "http://localhost:${var.port}"
-  icon         = local.icon_url
+  icon         = "/icon/jupyter.svg"
   subdomain    = true
   share        = "owner"
 }

jupyterlab/run.sh

@@ -1,22 +1,25 @@
 #!/usr/bin/env sh
 
-echo "Instalalting ${MODULE_NAME}..."
+BOLD='\033[0;1m'
+
+echo "$${BOLD}Installing jupyterlab!\n"
 
 # check if jupyterlab is installed
-if ! command -v jupyterlab &> /dev/null then
+if ! command -v jupyterlab > /dev/null 2>&1; then
     # install jupyterlab
     # check if python3 pip is installed
-    if ! command -v pip3 &> /dev/null then
+    if ! command -v pip3 > /dev/null 2>&1; then
         echo "pip3 is not installed"
-        echo "Please install pip3 and try again"
+        echo "Please install pip3 in your Dockerfile/VM image before running this script"
         exit 1
     fi
-    pip3 install jupyterlab
+    # install jupyterlab
-    echo "jupyterlab installed!"
+    pip3 install --upgrade --no-cache-dir --no-warn-script-location jupyterlab
+    echo "🥳 jupyterlab has been installed\n\n"
+else
+    echo "🥳 jupyterlab is already installed\n\n"
 fi
 
-echo "Starting ${MODULE_NAME}..."
+echo "👷 Starting jupyterlab in background..."
-
+echo "check logs at ${LOG_PATH}"
-$HOME/.local/bin/jupyter lab --no-browser --LabApp.token='' --LabApp.password='' >${LOG_PATH} 2>&1 &
+$HOME/.local/bin/jupyter lab --ServerApp.ip='0.0.0.0' --ServerApp.port=${PORT}  --no-browser --ServerApp.token='' --ServerApp.password='' >${LOG_PATH} 2>&1 &
-
-echo "Started ${MODULE_NAME}!"

kasmvnc/README.md

@@ -1,39 +0,0 @@
----
-display_name: KasmVNC
-description: A modern open source VNC server
-icon: ../.icons/kasmvnc.svg
-maintainer_github: coder
-verified: true
-tags: [helper, VNC, web]
----
-
-# KasmVNC
-
-Automatically install [KasmVNC](https://kasmweb.com/kasmvnc) in a workspace, and create an app to access it via the dashboard.
-
-## Examples
-
-1. Add latest version of KasmVNC with [`lxde`](https://www.lxde.org/) desktop environment:
-
-   ```hcl
-   module "kasmvnc" {
-     source   = "https://registry.coder.com/modules/kasmvnc"
-     agent_id = coder_agent.example.id
-   }
-
-   ```
-
-2. Add specific version of KasmVNC with [`mate`](https://mate-desktop.org/) desktop environment and custom port:
-
-   ```hcl
-   module "kasmvnc" {
-     source              = "https://registry.coder.com/modules/kasmvnc"
-     agent_id            = coder_agent.example.id
-     version             = "1.0.0"
-     desktop_environment = "mate"
-     port                = 6080
-   }
-
-   ```
-
-![Screenshot of KasmVNC]() //TODO

kasmvnc/main.tf

@@ -1,55 +0,0 @@
-terraform {
-  required_version = ">= 1.0"
-
-  required_providers {
-    coder = {
-      source  = "coder/coder"
-      version = ">= 0.12"
-    }
-  }
-}
-
-variable "agent_id" {
-  type        = string
-  description = "The ID of a Coder agent."
-}
-
-variable "port" {
-  type        = number
-  description = "The port to run KasmVNC on."
-  default     = 8443
-}
-
-variable "desktop_environment" {
-  type        = string
-  description = "The desktop environment to for KasmVNC (xfce, lxde, mate, etc)."
-  default     = "lxde"
-}
-
-variable "version" {
-  type        = string
-  description = "Version of KasmVNC to install."
-  default     = "1.2.0"
-}
-
-resource "coder_script" "kasm_vnc" {
-  agent_id     = var.agent_id
-  display_name = "KasmVNC"
-  icon         = "/icon/kasmvnc.svg"
-  script = templatefile("${path.module}/run.sh", {
-    PORT : var.port,
-    DESKTOP_ENVIRONMENT : var.desktop_environment,
-    VERSION : var.version
-  })
-  run_on_start = true
-}
-
-resource "coder_app" "kasm_vnc" {
-  agent_id     = var.agent_id
-  slug         = "kasm-vnc"
-  display_name = "kasmVNC"
-  url          = "http://localhost:${var.port}"
-  icon         = "/icon/kasmvnc.svg"
-  subdomain    = false
-  share        = "owner"
-}

kasmvnc/run.sh

@@ -1,40 +0,0 @@
-#!/usr/bin/env bash
-
-# Check if desktop enivronment is installed
-if ! dpkg -s ${DESKTOP_ENVIRONMENT} &>/dev/null; then
-    sudo apt-get update
-    DEBIAN_FRONTEND=noninteractive sudo apt-get install -y ${DESKTOP_ENVIRONMENT}
-else
-    echo "${DESKTOP_ENVIRONMENT} is already installed."
-fi
-
-# Check if vncserver is installed
-if ! dpkg -s kasmvncserver &>/dev/null; then
-    cd /tmp
-    wget https://github.com/kasmtech/KasmVNC/releases/download/v${VERSION}/kasmvncserver_focal_${VERSION}_amd64.deb
-    sudo apt install -y ./kasmvncserver_focal_${VERSION}_amd64.deb
-    printf "🥳 KasmVNC v${VERSION} has been successfully installed!\n\n"
-else
-    echo "KasmVNC is already installed."
-fi
-
-sudo addgroup $USER ssl-cert
-
-# Coder port-forwarding from dashboard only supports HTTP
-sudo bash -c 'cat > /etc/kasmvnc/kasmvnc.yaml <<EOF
-network:
-  protocol: http
-  websocekt_port: ${PORT}
-  ssl:
-    require_ssl: false
-  udp:
-    public_ip: 127.0.0.1
-EOF'
-
-# This password is not used since we start the server without auth.
-# The server is protected via the Coder session token / tunnel
-# and does not listen publicly on the VM
-echo -e "password\npassword\n" | vncpasswd -wo -u $USER
-
-# Start the server :)
-sudo su -u $USER bash -c 'vncserver -select-de "${DESKTOP_ENVIRONMENT}" -disableBasicAuth'

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "modules",
+  "scripts": {
+    "test": "bun test",
+    "fmt": "bun x prettier -w **/*.ts **/*.md *.md && terraform fmt **/*.tf",
+    "fmt:ci": "bun x prettier --check **/*.ts **/*.md *.md && terraform fmt -check **/*.tf"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.3"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

personalize/README.md

@@ -10,3 +10,10 @@ tags: [helper]
 # Personalize
 
 Run a script on workspace start that allows developers to run custom commands to personalize their workspace.
+
+```hcl
+module "personalize" {
+  source = "https://registry.coder.com/modules/personalize"
+  agent_id = coder_agent.example.id
+}
+```

personalize/main.tf

@@ -29,10 +29,10 @@ variable "log_path" {
 resource "coder_script" "personalize" {
   agent_id = var.agent_id
   script = templatefile("${path.module}/run.sh", {
-        PERSONALIZE_PATH: var.path,
+    PERSONALIZE_PATH : var.path,
   })
   display_name = "Personalize"
-    icon = "/emojis/1f58c.png"
+  icon         = "/icon/personalize.svg"
   log_path     = var.log_path
   run_on_start = true
 }

setup.ts

@@ -0,0 +1,49 @@
+import { readableStreamToText, spawn } from "bun";
+import { afterAll, beforeAll } from "bun:test";
+
+const removeStatefiles = async () => {
+  const proc = spawn([
+    "find",
+    ".",
+    "-type",
+    "f",
+    "-o",
+    "-name",
+    "*.tfstate",
+    "-o",
+    "-name",
+    "*.tfstate.lock.info",
+    "-delete",
+  ]);
+  await proc.exited;
+};
+
+const removeOldContainers = async () => {
+  let proc = spawn([
+    "docker",
+    "ps",
+    "-a",
+    "-q",
+    "--filter",
+    `label=modules-test`,
+  ]);
+  let containerIDsRaw = await readableStreamToText(proc.stdout);
+  let exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(containerIDsRaw);
+  }
+  containerIDsRaw = containerIDsRaw.trim();
+  if (containerIDsRaw === "") {
+    return;
+  }
+  proc = spawn(["docker", "rm", "-f", ...containerIDsRaw.split("\n")]);
+  const stdout = await readableStreamToText(proc.stdout);
+  exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(stdout);
+  }
+};
+
+afterAll(async () => {
+  await Promise.all([removeStatefiles(), removeOldContainers()]);
+});

test.ts

@@ -0,0 +1,212 @@
+import { readableStreamToText, spawn } from "bun";
+import { afterEach, expect, it } from "bun:test";
+import { readFile, unlink } from "fs/promises";
+
+export const runContainer = async (
+  image: string,
+  init = "sleep infinity",
+): Promise<string> => {
+  const proc = spawn([
+    "docker",
+    "run",
+    "--rm",
+    "-d",
+    "--label",
+    "modules-test=true",
+    "--entrypoint",
+    "sh",
+    image,
+    "-c",
+    init,
+  ]);
+  let containerID = await readableStreamToText(proc.stdout);
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(containerID);
+  }
+  return containerID.trim();
+};
+
+// executeScriptInContainer finds the only "coder_script"
+// resource in the given state and runs it in a container.
+export const executeScriptInContainer = async (
+  state: TerraformState,
+  image: string,
+): Promise<{
+  exitCode: number;
+  stdout: string[];
+  stderr: string[];
+}> => {
+  const instance = findResourceInstance(state, "coder_script");
+  const id = await runContainer(image);
+  const resp = await execContainer(id, ["sh", "-c", instance.script]);
+  const stdout = resp.stdout.trim().split("\n");
+  const stderr = resp.stderr.trim().split("\n");
+  return {
+    exitCode: resp.exitCode,
+    stdout,
+    stderr,
+  };
+};
+
+export const execContainer = async (
+  id: string,
+  cmd: string[],
+): Promise<{
+  exitCode: number;
+  stderr: string;
+  stdout: string;
+}> => {
+  const proc = spawn(["docker", "exec", id, ...cmd], {
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const [stderr, stdout] = await Promise.all([
+    readableStreamToText(proc.stderr),
+    readableStreamToText(proc.stdout),
+  ]);
+  const exitCode = await proc.exited;
+  return {
+    exitCode,
+    stderr,
+    stdout,
+  };
+};
+
+export interface TerraformState {
+  outputs: {
+    [key: string]: {
+      type: string;
+      value: any;
+    };
+  }
+  resources: [
+    {
+      type: string;
+      name: string;
+      provider: string;
+      instances: [
+        {
+          attributes: {
+            [key: string]: any;
+          };
+        },
+      ];
+    },
+  ];
+}
+
+export interface CoderScriptAttributes {
+  script: string;
+  agent_id: string;
+  url: string;
+}
+
+// findResourceInstance finds the first instance of the given resource
+// type in the given state. If name is specified, it will only find
+// the instance with the given name.
+export const findResourceInstance = <T extends "coder_script" | string>(
+  state: TerraformState,
+  type: T,
+  name?: string,
+  // if type is "coder_script" return CoderScriptAttributes
+): T extends "coder_script"
+  ? CoderScriptAttributes
+  : Record<string, string> => {
+  const resource = state.resources.find(
+    (resource) =>
+      resource.type === type && (name ? resource.name === name : true),
+  );
+  if (!resource) {
+    throw new Error(`Resource ${type} not found`);
+  }
+  if (resource.instances.length !== 1) {
+    throw new Error(
+      `Resource ${type} has ${resource.instances.length} instances`,
+    );
+  }
+  return resource.instances[0].attributes as any;
+};
+
+// assertRequiredVariables creates a test-case
+// for each variable provided and ensures that
+// the apply fails without it.
+export const testRequiredVariables = (
+  dir: string,
+  vars: Record<string, string>,
+) => {
+  // Ensures that all required variables are provided.
+  it("required variables", async () => {
+    await runTerraformApply(dir, vars);
+  });
+  const varNames = Object.keys(vars);
+  varNames.forEach((varName) => {
+    // Ensures that every variable provided is required!
+    it("missing variable " + varName, async () => {
+      const localVars = {};
+      varNames.forEach((otherVarName) => {
+        if (otherVarName !== varName) {
+          localVars[otherVarName] = vars[otherVarName];
+        }
+      });
+      try {
+        await runTerraformApply(dir, localVars);
+      } catch (ex) {
+        expect(ex.message).toContain(
+          `input variable \"${varName}\" is not set, and has no default`,
+        );
+        return;
+      }
+      throw new Error(`${varName} is not a required variable!`);
+    });
+  });
+};
+
+// runTerraformApply runs terraform apply in the given directory
+// with the given variables. It is fine to run in parallel with
+// other instances of this function, as it uses a random state file.
+export const runTerraformApply = async (
+  dir: string,
+  vars: Record<string, string>,
+): Promise<TerraformState> => {
+  const stateFile = `${dir}/${crypto.randomUUID()}.tfstate`;
+  const env = {};
+  Object.keys(vars).forEach((key) => (env[`TF_VAR_${key}`] = vars[key]));
+  const proc = spawn(
+    [
+      "terraform",
+      "apply",
+      "-compact-warnings",
+      "-input=false",
+      "-auto-approve",
+      "-state",
+      stateFile,
+    ],
+    {
+      cwd: dir,
+      env,
+      stderr: "pipe",
+      stdout: "pipe",
+    },
+  );
+  const text = await readableStreamToText(proc.stderr);
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(text);
+  }
+  const content = await readFile(stateFile, "utf8");
+  await unlink(stateFile);
+  return JSON.parse(content);
+};
+
+// runTerraformInit runs terraform init in the given directory.
+export const runTerraformInit = async (dir: string) => {
+  const proc = spawn(["terraform", "init"], {
+    cwd: dir,
+  });
+  const text = await readableStreamToText(proc.stdout);
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error(text);
+  }
+};

tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "types": ["bun-types"]
+  }
+}

vscode-desktop/README.md

@@ -12,3 +12,10 @@ tags: [ide, vscode, helper]
 Add a button to open any workspace with a single click.
 
 Uses the [Coder Remote VS Code Extension](https://github.com/coder/vscode-coder).
+
+```hcl
+module "vscode" {
+  source = "https://registry.coder.com/modules/vscode-desktop"
+  agent_id = coder_agent.example.id
+}
+```

vscode-desktop/main.tf

@@ -19,8 +19,9 @@ data "coder_workspace" "me" {}
 resource "coder_app" "vscode" {
   agent_id     = var.agent_id
   external     = true
-	icon = "/icons/code.svg"
+  icon         = "/icon/code.svg"
   slug         = "vscode"
+  display_name = "VS Code Desktop"
   url = join("", [
     "vscode://coder.coder-remote/open?owner=",
     data.coder_workspace.me.owner,