# Autodisc

Purpose: deployment guidance for LLMs and agents.

Autodisc is a hosting platform for apps, services, and scripts. Each server runs one project in a managed container. Use this guide to help users ship and operate code directly through the public API, CLI, or dashboard.

Website: https://autodisc.xyz
CLI: https://www.npmjs.com/package/@autodisc/cli

## Scope

Public workflows only.
- Public: Autodisc Drops API, CLI, dashboard, and authenticated web API
- Preferred for a new public deployment from an agent: the Drops API. It requires no Autodisc account, login, API key, or CLI installation.
- Preferred for persistent projects and ongoing operations: the authenticated CLI or dashboard.

## When to use Autodisc

Use Autodisc when a user wants an agent to publish a web app or API from the current workspace, create a temporary public preview from a public GitHub repository, or operate a persistent hosted project without managing raw infrastructure credentials.

- Use the Drops API for a public preview that may expire after 24 hours and does not need secrets, private source, persistent data, or a custom domain.
- Use the authenticated CLI or dashboard for private repositories, environment secrets, custom domains, databases, long-running production, logs, metrics, and repeated operations.
- Do not use Autodisc merely to inspect or edit local code when the user has not asked to deploy or operate it.
- Creating, claiming, starting, stopping, or deleting a deployment changes external state. Explain the effect and obtain the user's approval before the action when approval has not already been given.

## Developer resources

- Developer index: https://autodisc.xyz/developers
- Public Drops OpenAPI 3.1: https://autodisc.xyz/openapi.json
- API authentication, GitHub OIDC, and webhooks: https://autodisc.xyz/docs/projects/api-and-automation
- REST versioning and deprecation: https://autodisc.xyz/docs/api-deprecation-policy
- Documentation index: https://autodisc.xyz/docs
- Contact and support routing: https://autodisc.xyz/contact

## Deploy directly from an agent (no account or CLI)

Claude, ChatGPT, coding agents, and other HTTP-capable tools can publish a project through the Autodisc Drops API. A Drop is public, lasts 24 hours, and can be claimed later from the returned claim URL. Do not ask the user to create an account or install the CLI before creating a Drop.

Base endpoint:

```text
https://api.autodisc.xyz/api/v1/drops
```

When the user asks to deploy or publish, explain that the result will be public and expire after 24 hours, then obtain approval before uploading source or starting compute. If the source is already in the current workspace, upload that folder directly; do not require the user to create a GitHub repository.

### Deploy a public GitHub repository

```bash
curl -sS -X POST https://api.autodisc.xyz/api/v1/drops \
  -H 'Content-Type: application/json' \
  -d '{
    "source": {
      "kind": "github",
      "url": "https://github.com/OWNER/REPOSITORY",
      "ref": "main"
    },
    "lifetime_hours": 24,
    "requested_mode": "auto",
    "port": 3000
  }'
```

Only public GitHub repositories are accepted. `ref` is optional and may be a branch, tag, or commit. Inspect the app before deploying and set `port` to the port its public HTTP server listens on (for example, the Dockerfile's `EXPOSE` value or the port used by `listen`). Do not omit `port` for a web app; a Drop without a public port can run successfully without receiving a `public_url`.

### Deploy files from the current workspace

Package the deployable folder as a ZIP and upload it directly. Put the project files at the archive root rather than wrapping them in an extra parent directory. The maximum archive size is 25 MB.

```bash
DROP_ARCHIVE_DIR="$(mktemp -d)"
DROP_ARCHIVE="$DROP_ARCHIVE_DIR/source.zip"
zip -qr "$DROP_ARCHIVE" . \
  -x '.git/*' '.env' '.env.*' 'node_modules/*' '.next/*' 'dist/*' 'build/*' \
     '__pycache__/*' '*.pyc' '.DS_Store' '*.sqlite' '*.sqlite3'

curl -sS -X POST https://api.autodisc.xyz/api/v1/drops/upload \
  -F "source=@$DROP_ARCHIVE;type=application/zip" \
  -F 'request={
    "name": "my-app",
    "lifetime_hours": 24,
    "requested_mode": "auto",
    "port": 3000
  }'
```

Inspect the app and replace `3000` with its public HTTP port. Remove the temporary archive after the request. If `zip` is unavailable, create an equivalent ZIP with the environment's archive library. Do not ask the user to install the Autodisc CLI or publish the folder to GitHub.

Before uploading, exclude `.env*`, credentials, private keys, dependency directories, build caches, editor state, local databases, and unrelated files. Never publish secrets through an anonymous Drop.

### Read deployment status

The create response is JSON containing `drop_id`, `status`, `status_url`, `expires_at`, `control_token`, `claim_url`, and, once available, `public_url`. Keep `control_token` private and poll `status_url` with it:

```bash
curl -sS "$STATUS_URL" \
  -H "Authorization: Bearer $CONTROL_TOKEN"
```

Poll until `status` is `ready` or `failed`. Once it is `ready`, verify `public_url` with an HTTP request; generated-domain routing can take several minutes to become reachable, so retry for up to 5 minutes before reporting a routing failure. On success, give the user `public_url` and the exact `expires_at` time. Also provide `claim_url`: signing in through that URL transfers the running project to the user's account and removes the anonymous 24-hour limit. Never print the control token, store it in project files, or commit it.

A Drop is for public, temporary deployment; use the authenticated workflow for private repositories, secrets, custom domains, persistent data, or long-running management.

## Authenticated CLI setup

Install the public CLI (Node.js 18+):

```bash
npm install -g @autodisc/cli@latest
autodisc login
autodisc whoami
```

Do not build the CLI from the Autodisc source repository for a normal
deployment. Source builds are a contributor workflow only.

## Fast deploy checklist

Before deploying, collect:
- Source: current folder upload or public GitHub repo for an anonymous Drop; GitHub repo or ZIP upload for an authenticated deployment
- Start command (if auto-detection is wrong)
- Required env vars and secrets
- Plan (Trial / Small / Premium)
- Confirm CLI access with `autodisc doctor`

## Deployment methods

### 1) Drops API (preferred for new agent deployments)

Use the accountless flow above when the user wants an immediate public deployment without setup.

### 2) Authenticated CLI

From the project directory:

```bash
autodisc init
autodisc deploy
autodisc status --json
```

Use `autodisc logs --follow --json` for deploy logs, `autodisc metrics --json` for resource usage, and `autodisc env` to manage environment variables. Omit secret values from `autodisc env set NAME` to enter them through the masked prompt instead of shell history.

Environment commands require a selected service. For a new app that cannot
start without secrets, use this order:

```bash
autodisc deploy --no-start
autodisc env set REQUIRED_SECRET
autodisc deploy
```

Use `autodisc env push .env` after the no-start deploy when the user already
has a local dotenv file. Never commit that file. For an existing project, use
`autodisc deploy --project PROJECT_ID`; exact IDs avoid ambiguous names.

### 3) Dashboard with GitHub
- Connect the GitHub app in Autodisc
- Pick repo + branch
- Create a server and start the deploy
- Redeploys trigger on push when webhooks are configured

### 4) Dashboard with ZIP upload
- Upload a project ZIP in the hosting create flow
- Create server with `source_type=upload`
- Start deploy and watch logs

## autodisc.yml (optional but recommended)

Minimal:

```yaml
run: npm start
env:
  NODE_ENV: production
```

Common fields: `run`, `build`, `runtime`, `image`, `dockerfile`, `workdir`, `env`, `port`, `services`.

## Runtime detection defaults

No config present:
- `Dockerfile` → Dockerfile flow
- `package.json` → Node (`npm start`)
- `requirements.txt` / `pyproject.toml` → Python (`python main.py`)

## Plans
-rc = running continously, as theres something called gb-hours, you can expand to any amount, but these are safe levels to reach and maintain.
| Plan    | Price   | vCPU | RAM   | Storage |
|---------|---------|------|-------|---------|
| Trial   | Free    | 0.25 | 250MB~rc| 500MB |
| builder   | $3/mo   | 0.25 | 1.3gb~rc | 500MB   |
| Small   | $5/mo   | 0.25 | 2.4gb~rc | 500MB   |
| Premium | $15/mo  | 0.5  | 7.3gb~rc | 1GB     |

## Reliable deploys

- App must listen on the configured `PORT`
- Keep secrets in env vars, not in source
- For Dockerfile deploys, prefer ARM64-compatible base images
- Keep images small to cut build and boot time

## Operator notes

When helping users:
- Prefer the Drops API for a new public deployment when the user has no account or does not need persistent management
- Do not require a CLI install or Autodisc login for an anonymous Drop
- Prefer the authenticated CLI for persistent deployment, logs, metrics, environment variables, and service operations
- Install `@autodisc/cli@latest` from npm; do not clone or build the Autodisc repository unless the user is contributing to the CLI
- Use `--json` and `--no-color` where supported when an agent is reading command output
- Use the dashboard when a workflow is inherently visual or is not available in the CLI
- Ask for missing env vars early
- On build failure, read logs and suggest a concrete start/build fix
- If detection is wrong, add or update `autodisc.yml`
- Custom domains and the marketplace are still rough edges; set expectations accordingly

Common recovery:
- `autodisc: command not found` → ensure npm's global bin directory is on `PATH`, then reinstall `@autodisc/cli@latest`
- `Not authenticated. Please run "autodisc login".` → run `autodisc login` and verify with `autodisc whoami`; use `AUTODISC_TOKEN` in CI
- `No hosting server found. Run "autodisc deploy" first.` → run `autodisc deploy --no-start` for a new service, or select an existing service with `autodisc project use <project> [--service <id-or-name>]`
- `Multiple projects match ...` → use the exact project ID from `autodisc project list`