Docs / Build and deploy

Functions, buckets and sandboxes

Three kinds of service need no repository: a function is one file of code you edit in the dashboard, a bucket is S3-compatible storage, and a sandbox is a Linux machine for running commands. All three are in the canvas’s Create menu.

Functions

A function is a service made of one file. Dawnrose keeps the code with the service, so you or your agent can read it, change it and deploy it again without a repository.

Create a function

1. Click Create and choose Function.
2. Enter a name, pick TypeScript or Python, and pick HTTP endpoint or Scheduled job. For a job, enter a Schedule (UTC) as a 5-field crontab.
3. Click Create function. Dawnrose deploys starter code right away.

Agents use create_function, which takes the same choices and optional code. Without code it deploys the starter.

Runtimes

A function is one file of up to 256 KB and cannot install packages. For dependencies, deploy a repository or upload a folder instead. The service’s variables are in process.env or os.environ.

HTTP functions and scheduled jobs

An HTTP function must listen on $PORT. After its first deploy it gets a public URL, shown next to the file name in the Code tab. The TypeScript starter looks like this:

import { createServer } from "node:http";

const server = createServer(async (req, res) => {
	const url = new URL(req.url ?? "/", "http://localhost");
	res.setHeader("content-type", "application/json");
	res.end(JSON.stringify({ hello: "world", path: url.pathname, at: new Date().toISOString() }));
});

server.listen(Number(process.env.PORT ?? 3000));

A scheduled job is a cron service: each run starts the file, which does its work and exits. Its output appears in the logs, and the Cron tab lists the runs.

Edit and deploy

The Code tab holds the file. Edit it, change the Schedule if you want (empty means an HTTP function), and click Deploy or press ⌘S. Revert discards your edits. Every save deploys a new version. Agents read the code with get_function and change it with update_function.

Buckets

A bucket is an S3-compatible storage service (RustFS) with a bucket already created and keys your apps can use.

Create a bucket

1. Click Create and choose Bucket.
2. Enter a Bucket name: 3 to 63 lowercase letters, digits or hyphens. The default is files. The service gets the same name.
3. Click Create bucket.

Agents deploy the bucket template, which creates a service named Bucket with a bucket named files.

After the first deploy, Dawnrose creates the bucket if it does not exist and checks that the keys can write and delete objects. The Deployments tab then shows the access key and secret key. The data lives on the service’s volume at /data.

Variables

Reference them from your app. For a bucket service named files:

S3_ENDPOINT=${{ files.S3_ENDPOINT }}
S3_BUCKET=${{ files.S3_BUCKET }}
S3_REGION=${{ files.S3_REGION }}
AWS_ACCESS_KEY_ID=${{ files.S3_ACCESS_KEY_ID }}
AWS_SECRET_ACCESS_KEY=${{ files.S3_SECRET_ACCESS_KEY }}

Configure your S3 client for path-style requests (in the AWS SDK for JavaScript, forcePathStyle: true). The private hostname has no per-bucket subdomains.

Sandboxes

A sandbox is a Linux service based on the node:22-bookworm image, with Node 22, Python 3 and git. It stays running without serving traffic and has no public domain. Use it to try code, clone a repository or let your agent run commands.

1. Click Create and choose Sandbox.
2. Enter a name and click Create sandbox.

Work in it from its Console tab, a terminal that starts in /workspace. Agents use exec_command, and you can use dawn exec. Agents can also create one by deploying the sandbox template.

Files are kept until the sandbox restarts. To keep them longer, add a volume under Settings → Volume with the mount path /workspace and redeploy.

The Console tab

Every service has a Console tab with a terminal: a live shell inside its running replica, the same as SSH. Type straight into it.

• It opens bash when the image has it, otherwise ash or sh. The shell stays open while the tab is, so cd, variables and running programs carry over from one command to the next.
• Tab completion, history on the arrow keys, Ctrl+C, colors and full-screen programs such as vim, less and top work, and the terminal follows the panel’s size.
• Closing the tab or the page ends the shell and everything it started. Reconnect opens a new one. A terminal closes after an hour without typing.
• Files you write stay until the service restarts. A new deployment starts from the image again.
• The service needs an active deployment. A sleeping service is woken first. With several replicas, the terminal opens in the first one.

Opening a terminal needs the member role or higher and is recorded in the activity log. For a single command from a script, use dawn exec or the agent tool exec_command, which allows up to 600 seconds.

Agents get a shell that stays open too: open_shell, then run_in_shell for each command and close_shell at the end. The directory, exported variables and background processes carry over between commands, and a command that runs longer than its timeout can be waited on with another call. Agent shells close after 30 minutes unused. See MCP tools.

dawn exec --service api -- 'ls -la && df -h'