Templates

import { TenkiSandbox } from "@tenkicloud/sandbox";

const sandbox = new TenkiSandbox();

// 1. Define the template
const tpl = await sandbox.createTemplate({
  name: "my-node-env",
  setupScript: "curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && apt-get install -y nodejs",
  startCmd: "node --version",
  env: { NODE_ENV: "production" },
});

// 2. Build it and wait until it is READY
const build = await sandbox.buildTemplate(tpl.id);
await sandbox.waitForTemplateBuild(build.id);

// 3. Publish it to the registry (workspace + name + tag form the reference)
await sandbox.publishRegistryImage({
  workspaceId: "ws-123",
  name: "my-node-env",
  fromTemplateId: tpl.id,
  tag: "latest",
  visibility: "private",
});

// 4. Create a session from the published reference
const session = await sandbox.createAndWait({ image: "myworkspace/my-node-env:latest" });

from tenki_sandbox import Client

client = Client()

# 1. Define the template
tpl = client.templates.create(
    name="my-node-env",
    setup_script="curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && apt-get install -y nodejs",
    start_cmd="node --version",
    env={"NODE_ENV": "production"},
)

# 2. Build it and wait until it is READY
build = client.templates.build(tpl.id)
client.templates.wait_build(build.id)

# 3. Publish it to the registry (workspace + name + tag form the reference)
client.registry.publish(
    workspace_id="ws-123",
    name="my-node-env",
    kind="template",
    source_template_id=tpl.id,
    tag="latest",
    visibility="private",
)

# 4. Create a session from the published reference
session = client.create(image="myworkspace/my-node-env:latest")

import tenkisandbox "github.com/TenkiCloud/tenki-sdk-go/sandbox"

client, err := tenkisandbox.New()

// 1. Define the template
tpl, err := client.CreateTemplate(
  ctx,
  tenkisandbox.WithTemplateName("my-node-env"),
  tenkisandbox.WithSetupScript("curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && apt-get install -y nodejs"),
  tenkisandbox.WithStartCmd("node --version"),
  tenkisandbox.WithEnvs(map[string]string{"NODE_ENV": "production"}),
)

// 2. Build it and wait until it is READY
build, err := client.BuildTemplate(ctx, tpl.ID)
_, err = client.WaitForTemplateBuild(ctx, build.ID)

// 3. Publish it to the registry (workspace + name + tag form the reference)
_, err = client.PublishRegistryImage(
  ctx,
  tenkisandbox.WithRegistryWorkspaceName("ws-123", "my-node-env"),
  tenkisandbox.WithRegistryTemplate(tpl.ID),
  tenkisandbox.WithRegistryTag("latest"),
  tenkisandbox.WithRegistryVisibility(tenkisandbox.RegistryVisibilityPrivate),
)

// 4. Create a session from the published reference
session, err := client.Create(ctx, tenkisandbox.WithImage("myworkspace/my-node-env:latest"))

# 1. Define the template (only --name and --setup-script are required)
tenki sandbox template create \
  --name my-node-env \
  --setup-script 'curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && apt-get install -y nodejs' \
  --start-cmd 'node --version' \
  --env NODE_ENV=production

# 2. Build it and wait until it is READY
tenki sandbox template build <template-id> --wait

# 3. Publish it to the workspace registry
tenki sandbox registry publish \
  --image myworkspace/my-node-env:latest \
  --from-template <template-id> \
  --visibility private

# 4. Create a session from the published reference
tenki sandbox create --image myworkspace/my-node-env:latest

const templates = await sandbox.listTemplates();
const tpl = await sandbox.getTemplate(templateId);
await sandbox.deleteTemplate(templateId);

templates = client.templates.list()
tpl = client.templates.get(template_id)
client.templates.delete(template_id)

templates, err := client.ListTemplates(ctx)
tpl, err := client.GetTemplate(ctx, templateID)
err = client.DeleteTemplate(ctx, templateID)

tenki sandbox template list
tenki sandbox template get <template-id>
tenki sandbox template update <template-id> --start-cmd 'node server.js'
tenki sandbox template delete <template-id>

const images = await sandbox.listRegistryImages({ workspace: "myworkspace", kind: "template" });
const image = await sandbox.getRegistryImage("myworkspace/my-node-env:latest");
const resolved = await sandbox.resolveRegistryRef("myworkspace/my-node-env:latest");

images = client.registry.list("myworkspace", kind="template")
image = client.registry.get("myworkspace/my-node-env:latest")
resolved = client.registry.resolve("myworkspace/my-node-env:latest")

images, err := client.ListRegistryImages(
  ctx,
  tenkisandbox.WithRegistryWorkspace("myworkspace"),
  tenkisandbox.WithRegistryKind(tenkisandbox.RegistryImageKindTemplate),
)
image, err := client.GetRegistryImage(ctx, "myworkspace/my-node-env:latest")
resolved, err := client.ResolveRegistryRef(ctx, "myworkspace/my-node-env:latest")

tenki sandbox registry list --workspace myworkspace --kind template
tenki sandbox registry get myworkspace/my-node-env:latest
tenki sandbox registry resolve myworkspace/my-node-env:latest