Superviseur | Superviseur

HCL
TypeScript
Gleam
Go
Rust

project = "demo"

service "demo" {
  type = "exec"
  command = "ping $GITHUB_DOMAIN"
  working_dir = "/tmp"
  description = "Ping Service Example"
  depends_on = []
  env = {
    "GITHUB_DOMAIN" = "github.com"
  }
  stdout = "/tmp/demo-stdout.log"
  stderr = "/tmp/demo-stderr.log"
}
  

import * as path from "https://deno.land/std/path/mod.ts";
import { connect } from "../client.ts";
import Service from "../service.ts";

if (import.meta.main) {
  const deno = new Service()
    .withName("deno-fresh")
    .withCommand("./dev.ts")
    .withEnv({
      PORT: "8000",
    });

  const projectDir = path.resolve("../../examples/deno-fresh");

  const response = await connect()
    .newProject()
    .withName("deno-example")
    .withContext(projectDir)
    .withService(deno)
    .stdout();

    console.log(response);
}

import project.{stdout, with_context, with_service}
import service.{new_service, with_command, with_env, with_name}
import client.{connect, with_project}

pub fn main() {
  let deno_fresh =
    new_service()
    |> with_name("deno-fresh")
    |> with_command("./dev.ts")
    |> with_env(["PORT=8000"])

  let project =
    connect()
    |> with_project("deno-example")
    |> with_context(
      "../examples/deno-fresh",
    )
    |> with_service(deno_fresh)

  project
  |> stdout()
}

package main

import (
  "fmt"
  "github.com/tsirysndr/go-superviseur/client"
  "github.com/tsirysndr/go-superviseur/service"
)

func main() {
  denoFresh := service.New().
    WithName("deno-fresh").
    WithCommand("./dev.ts").
    WithEnv(map[string]string{
      "PORT": "8000",
    })

  project := client.Connect().
    NewProject().
    WithName("deno-example").
    WithContext("../examples/deno-fresh").
    WithService(denoFresh)

  fmt.Println(project.Stdout())
}

use std::fs::canonicalize;
use superviseur_client::{client::connect, service::new_service};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let deno_fresh = new_service()
        .with_name("deno-fresh")
        .with_command("./dev.ts")
        .with_env("PORT", "8000");

    let project_dir = canonicalize("../../examples/deno-fresh")?;

    connect()
        .new_project("deno-example")
        .with_context(project_dir.to_str().unwrap())
        .with_service(deno_fresh)
        .stdout()
        .await?;

    Ok(())
}

Define and run multi-service applications on isolated environments with Nix or Docker using HCL or any language you already know.

Support many different environments and runtimes, including Docker, Nix, Spin, WebAssembly and more.

project = "demo"

service "redis" {
  type = "docker"
  command = "redis-server"
  working_dir = "."
  description = "Redis Service Example"
  depends_on = []
  env = {}
  port = 6379

  use "docker" {
    image = "redislabs/redismod:edge"
    ports = ["6379:6379"]
  }
}
 

project = "spin-demo"

service "http" {
  type = "wasm"
  command = "target/wasm32-wasi/release/http_server.wasm"
  working_dir = "."
  description = "HTTP server demo"
  depends_on = []
  env = { }
  port = 3000

  use "wasm" {
    runtime "spin" { } # or "wasmedge", "lunatic", "spiderlightning"
  }
}

project = "deno-fresh"

service "deno" {
  type = "exec"
  command = "./dev.ts"
  working_dir = "."
  description = "Deno example app"
  depends_on = []
  env = {}
  port = 8000

  use "nix" { }
}

project = "deno-fresh"

service "deno" {
  type = "exec"
  command = "./dev.ts"
  working_dir = "."
  description = "Deno example app"
  depends_on = []
  env = {}
  port = 8000

  use "flox" {
    environment = ".#deno-fresh"
  }
}
  

project = "deno-fresh"

service "deno" {
  type = "exec"
  command = "./dev.ts"
  working_dir = "."
  description = "Deno example app"
  depends_on = []
  env = {}
  port = 8000

  use "devenv" { }
}

project = "deno-fresh"

service "deno" {
  type = "exec"
  command = "./dev.ts"
  working_dir = "."
  description = "Deno example app"
  depends_on = []
  env = {}
  port = 8000

  use "devbox" {
    packages = ["deno"]
  }
}