Skip to main content

Onyx Developer Script

Deploy Status PyPI

ods is onyx.app's devtools utility script. It is packaged as a python wheel and available from PyPI.

Installation

A stable version of ods is provided in the default python venv which is synced automatically if you have pre-commit hooks installed.

While inside the Onyx repository, activate the root project's venv,

source .venv/bin/activate

Prerequisites

Some commands require external tools to be installed and configured:

  • Docker - Required for compose, logs, and pull commands

  • uv - Required for backend commands

  • GitHub CLI (gh) - Required for run-ci, cherry-pick, and trace commands

  • AWS CLI - Required for screenshot-diff commands (S3 baseline sync)

Autocomplete

ods provides autocomplete for bash, fish, powershell and zsh shells.

For more information, see ods completion <shell> --help for your respective <shell>.

zsh

Linux

ods completion zsh | sudo tee "${fpath[1]}/_ods" > /dev/null

macOS

ods completion zsh > $(brew --prefix)/share/zsh/site-functions/_ods

bash

ods completion bash | sudo tee /etc/bash_completion.d/ods > /dev/null

Note: bash completion requires the bash-completion package be installed.

Commands

Choose a development command

Task Command Lifetime
Frontend-only change with a healthy API already running ods web dev Foreground, stop with Ctrl-C
Run the API or model server from source ods backend api or ods backend model-server Foreground, stop with Ctrl-C
Run the application and its infrastructure ods stack up Background, inspect with ods stack status
Use a separate dataset and infrastructure ods --isolated stack up Background, inspect with ods --isolated stack status
Run a frontend build, test, or other package script ods web <script> [args...] Until the script exits
Run Onyx in Docker containers ods compose [profile] Docker-managed containers
Run Craft against the shared Firecracker dev cluster ods craft-dev api and ods craft-dev web Foreground, stop with Ctrl-C

Source commands use the selected project's ports and environment. Shared infrastructure is the default. --project NAME selects an existing project; --isolated selects separate worktree infrastructure. Neither option copies data. Keep container commands separate from source-process commands when troubleshooting.

Managed stacks and frontend attachment require macOS or Linux. On Windows, ods web dev and ods backend use portable foreground launchers with configured connection variables. They do not provide managed-stack ownership or attachment.

ods env updates connection variables from the selected project's running containers. It fails without changing .vscode/.env if that project's Postgres container has no published port.

compose - Launch Docker Containers

Launch Onyx docker containers using docker compose.

ods compose [profile]

Profiles:

  • dev - Use dev configuration (exposes service ports for development)
  • multitenant - Dev configuration plus the docker-compose.multitenant.yml overlay (multi-tenant mode)

Flags:

Flag Default Description
--down false Stop running containers instead of starting them
--wait true Wait for services to be healthy before returning
--force-recreate false Force recreate containers even if unchanged
--tag Set the IMAGE_TAG for docker compose (e.g. edge, v2.10.4)

Examples:

# Start containers with default configuration
ods compose

# Start containers with dev configuration
ods compose dev

# Start containers in multi-tenant mode
ods compose multitenant

# Stop running containers
ods compose --down
ods compose dev --down

# Start without waiting for services to be healthy
ods compose --wait=false

# Force recreate containers
ods compose --force-recreate

# Use a specific image tag
ods compose --tag edge

logs - View Docker Container Logs

View logs from running Onyx docker containers. Service names are available as arguments to filter output, with tab-completion support.

ods logs [service...]

Flags:

Flag Default Description
--follow true Follow log output
--tail Number of lines to show from the end of the logs

Examples:

# View logs from all services (follow mode)
ods logs

# View logs for a specific service
ods logs api_server

# View logs for multiple services
ods logs api_server background

# View last 100 lines and follow
ods logs --tail 100 api_server

# View logs without following
ods logs --follow=false

pull - Pull Docker Images

Pull the latest images for Onyx docker containers.

ods pull

Flags:

Flag Default Description
--tag Set the IMAGE_TAG for docker compose (e.g. edge, v2.10.4)

Examples:

# Pull images
ods pull

# Pull images with a specific tag
ods pull --tag edge

backend - Run Backend Services

Run backend services in the foreground with environment loaded from .vscode/.env. On first run, copies .vscode/env_template.txt to .vscode/.env if the .env file does not already exist.

ODS retains terminal control and forwards line input through a pipe. Programs that require terminal stdin or direct /dev/tty input need a separate launch.

Paid features need a license in the database. When ONYX_DEV_LICENSE is set, in the shell or in .vscode/.env, backend api seeds it before the server starts. compose reads it from the shell only and seeds it into the api_server once the stack is healthy, except with --infra, with --wait=false, and for the multitenant profile. With no license in the database Onyx runs as Community Edition.

ods backend <subcommand>

Subcommands:

  • api - Start the FastAPI backend server (uvicorn onyx.main:app --reload)
  • model-server - Start the model server (uvicorn model_server.main:app --reload). model_server remains an alias.

Flags:

Flag Default Description
--port Selected project's service port Override the port to listen on

Shell environment takes precedence over .env file values, so inline overrides work as expected (e.g. S3_ENDPOINT_URL=foo ods backend api).

Examples:

# Start the API server
ods backend api

# Start the API server on a custom port
ods backend api --port 9090

# Start the model server
ods backend model-server

# Start the model server on a custom port
ods backend model-server --port 9001

craft-dev - Run Craft Against the Firecracker Dev Cluster

Run a local Craft API and web server against the shared remote Firecracker dev cluster, and work with your own sandbox VM there. The commands run the Python launchers in deployment/helm/dev with uv run. That directory's README has the full workflow.

A profile file holds the cluster facts: --profile, else CRAFT_DEV_PROFILE, else dev/craft-dev.yaml in the onyx-internal checkout next to this repository. kubectl always gets an explicit context. --context (or CRAFT_DEV_CONTEXT) must be in the profile's kube.allowed_contexts.

ods craft-dev <subcommand>

Subcommands:

  • doctor - Check AWS SSO, VPN egress, kube access, Telepresence, host agent mTLS, and the Alembic head. Changes nothing.
  • api - Start the local API server. Needs telepresence connect. Arguments after -- go to uvicorn.
  • web - Start the local web server against the local API.
  • vms - Show your VM.
  • skills push <dir> - Put a local directory on a managed mount of your VM (--mount, --wake).
  • exec -- <command> - Run a command in your VM as the sandbox user (--wake, --cwd).
  • logs - Show the guest and agent lines of your VM (--guest, --agent, --since, --tail, -f).
  • reset - Save your sessions, then stop your VM (--force skips the save).

The VM commands act only on your user: --user, else CRAFT_DEV_USER, else user.email in the profile.

Examples:

ods craft-dev doctor
ods craft-dev api --port 8081
ods craft-dev web --port 8081
CRAFT_DEV_USER=me@example.com ods craft-dev skills push ./my-skills --wake
ods craft-dev exec -- ls -la /mnt/skills

Until an onyx-devtools release includes craft-dev, run it from source at the repository root: go -C tools/ods run . craft-dev doctor.

stack - Run the Local Dev Stack of a Worktree

Run the whole local dev stack from a source checkout without an editor: Compose infrastructure, migrations, and the application services from .vscode/launch.json as background processes. It is built for several agents and worktrees on one machine.

The stack uses the same service specifications and process launchers as ods web dev and ods backend. It does not invoke those commands through a shell.

ods stack <up|start|restart|stop|down|status|ls|prune|logs|plan> [flags]

By default, worktrees of one repository share Postgres, Redis, search, object storage, model servers, and one active application checkout. Shared state and the lifecycle lock live under git rev-parse --git-common-dir, in ods-stack-shared. Running up from another checkout stops the previous managed application processes before migrations, then starts the new code. status reports the active checkout. Other lifecycle commands require that checkout.

Use ods --isolated stack up for separate data, ports, and per-worktree state under git rev-parse --git-path ods-stack. Repeat this flag with status and shutdown commands. Existing isolated datasets remain intact. On first shared startup, ODS reuses a single existing legacy project. If several exist, choose one with ods --project NAME stack up. Stop that legacy stack with --isolated first. ODS remembers the selected project and never guesses between datasets. Project ownership is durable. An explicit --project that conflicts with another managed stack fails, including in isolated mode. Select a different project for independent infrastructure.

Legacy discovery uses saved ods stack state. A setup created only with ods compose dev has no such state. To keep its data, select its previous Compose project explicitly before the first shared startup, for example ods --project onyx stack up for an uncustomized checkout named onyx. Shared startup saves that project for later commands. Until then, repeat --project NAME with Compose and database commands. Existing volumes are not deleted.

For frontend-only diffs on macOS or Linux, prefer ods web dev. It starts the frontend against a healthy managed API. It does not start containers, install Python dependencies, run migrations, or start workers. Ctrl-C stops a preview started by this command. If a matching frontend already runs in this checkout, the command attaches to it, and Ctrl-C only detaches. The API keeps running. Ctrl-C also cancels dependency installation or library builds during startup. Restarting the API's stack can interrupt the preview. OAuth callbacks retain the API's original web origin. Use the full stack for backend changes and OAuth callback tests. stack status does not include standalone frontend previews. Starting the full stack in the same checkout replaces its preview with the managed frontend and retains its port.

Port leases live in ~/.local/share/onyx-dev/stack/ports.json. A stack keeps its ports while it runs. stop releases the application ports (web, API, MCP, model server and metrics) and keeps the infrastructure ports, because the containers still bind them. down releases every lease. When shared mode adopts a stopped legacy isolated stack, ODS releases that stack's leases first. A lease of another stack is reclaimed when that stack's state is stopped or missing, none of its process groups is alive, and, for a *_HOST_PORT lease, its Compose project has no running container. A stack that does not run moves down to the lowest free port from the preferred one (3000 for web, 8080 for the API). A leased port that something else took is replaced on the next start, so read the status again after a restart.

up takes the selected stack's lifecycle lock, so two agents running up at the same time converge on one stack: the second waits and then finds everything running. It then:

  1. Creates .vscode/.env and .vscode/.env.web from the templates when they are missing, with placeholders blanked, and turns a symlinked env file into a worktree-local copy. It never prints or replaces a value.
  2. Checks uv, bun and docker, runs uv sync --frozen and bun install when needed (--skip-prepare skips this step).
  3. Leases the infrastructure and application ports, writes the Compose port variables, and runs ods compose dev --infra for this project.
  4. Writes the infrastructure port variables to .vscode/.env (as ods env does) and checks migration state. Pending migrations stop managed application services before alembic upgrade head. If the database is already at head, unchanged healthy services keep running. Migrations use POSTGRES_HOST=localhost and the actual published Postgres port.
  5. Reconciles the services: a service whose process is still the one started earlier and whose command and environment are unchanged keeps running; everything else is stopped and started. An interrupted up is finished by the next one.
  6. Waits until the web server (/api/auth/type) and API server (/health) answer, then prints the status.

Services run in their own process groups with the shell, the launch configuration's envFile and env, and the stack's hosts and ports on top (POSTGRES_HOST, REDIS_HOST, OPENSEARCH_HOST, MODEL_SERVER_HOST, PORT, WEB_DOMAIN, INTERNAL_URL, MCP_SERVER_PORT, MCP_INTERNAL_URL, MODEL_SERVER_PORT). stop signals only the groups it started, checked by pid, group and start time, and waits for every descendant to exit before it forgets a service. down also stops the Compose containers; volumes are kept.

Profiles (--profile):

Profile Services
minimal Web Server, API Server
default minimal plus the primary, light, beat, docfetching, docprocessing and user_file_processing Celery workers
full Every service in the Run All Onyx Services compound

The model server comes from Compose and runs the edge image, which is built from main and bundles the checkout's default embedding model. The release image (latest) can lack that model, and the model server then downloads it from Hugging Face on the first embed. up pulls the current edge image and applies it when it creates or recreates the Compose containers; a failed pull keeps the cached image. start and restart do not touch the containers. Set ONYX_MODEL_SERVER_IMAGE or IMAGE_TAG in your shell to run another image. --local-model-server runs it from the checkout instead, on its own leased port, and leaves the Compose inference server down. The Slack bot (full only) binds its metrics server to port 8000; the stack never leases 8000 and skips the bot when the port is taken.

Flags (up, start, restart):

Flag Default Description
--profile default minimal, default or full
--local-model-server false Run the model server from the checkout
--timeout 3m How long to wait for the services to become healthy
--lock-wait 10m How long to wait for another lifecycle command on this worktree
--stop-timeout 20s Grace period before a stale service is killed
--skip-prepare false Skip uv sync and bun install
--json false Print the status as JSON

--isolated is a global option. Use it with status and shutdown commands too, for example ods --isolated stack down. Without it, commands use shared mode.

status --json reports the project, profile, phase (preparing, infra, migrating, starting, ready, degraded, stopped, failed), the leased ports, the URLs, each service with its state (running, exited, skipped), pid, health and log path, and any errors. A service that exited or is unhealthy also carries log_tail, the last lines of its log, so an agent can read the failure from the status alone. Its exit code is 0 when the stack is ready, 2 when it is not, and 1 when the worktree has no stack.

up, start and restart always print the status, also on failure. They exit 1 when startup fails, including a missing tool, dependency installation, Compose, migrations, or an exited required service. Migration diagnostics appear in errors. They exit 2 when running services do not become healthy within --timeout. They exit 3 when another lifecycle command still held the worktree lock after --lock-wait; the printed status is then the last recorded one. A service without a health check must stay alive for five seconds before the stack counts as ready, so a crash on startup is reported rather than hidden.

Find and stop old stacks:

ods stack ls [--json] [--all] [--orphaned] lists every dev stack on the machine, from any directory. It reads Docker, the project owner records in ~/.local/share/onyx-dev/stack/projects, the stack state in each repository's Git directory, and the port leases. It takes no locks and changes nothing. If Docker is unavailable, it prints a warning and lists the stacks from their saved state.

Status Meaning
orphaned No worktree owns the stack: its checkout or Compose directory is gone, or the directory is no longer a git worktree
active Application processes run
app-stopped Containers run, and ods stack stop stopped the application
infra-only Containers run, and no application process does
stopped Nothing runs (with --all)
stale-lease Port leases that no stack uses (with --all)

By default ls shows stacks with a running process or container, and orphans that left only Docker volumes. --all adds stopped stacks, and --orphaned shows only orphaned stacks. --json prints an array with the project, root, branch, mode, profile, phase, application and container counts, web URL, age, status, leases, errors, and next, the command that stops the stack. The text output prints the same command under the table. The exit code is 3 when --orphaned finds an orphan, and 1 when no source could be read.

ods stack down --project NAME and ods stack stop --project NAME work from any directory, also when the checkout is gone. They find the project through its owner record and saved state, or else through its Docker labels. They stop the recorded processes, and down runs docker compose -p NAME down (volumes are kept), releases the stack's port leases, and removes the owner record of an orphan. They refuse a stack that still runs in an existing worktree unless you add --force. ods stack prune runs down --project for every orphaned stack after a confirmation (--yes skips it). --volumes also deletes their Docker volumes, after a separate confirmation. A removed worktree whose stack was already down leaves only its volumes. ls shows it as orphaned, plain prune leaves it, and prune --volumes deletes the volumes. Plain prune keeps the owner record of a project with volumes, because that record is the only link from the removed worktree to them. When Docker cannot list the volumes, prune keeps every owner record. Docker keeps a volume that a container still uses, so prune --volumes lists the volumes again and keeps the owner record if any is left.

ods stack prune --idle 6h also stops each isolated stack whose worktree had no activity for 6 hours. Activity is the stack start, a Git operation in the worktree (commit, checkout, add, rebase), a change to a modified or untracked file, a deleted tracked file or directory, or a running coding agent (claude, codex, opencode, cursor-agent) whose working directory is in the worktree. Ignored files, such as service logs, do not count. ods finds agents through /proc on Linux and lsof on macOS. If ods cannot find the agents, prune --idle fails and stops nothing. If Git cannot read a worktree, prune warns and does not stop its stack. After the confirmation and the stack lock, prune checks the activity again and skips a stack that had activity since the listing. Shared stacks serve several worktrees, so prune never stops them as idle. Idle stacks keep their volumes, also with --volumes, so ods stack up in the worktree starts the stack again with its data. To prune on a schedule, run ods stack prune --idle 6h --yes from cron or a systemd timer.

Examples:

# Start everything a feature branch needs
ods stack up

# The whole compound, as JSON for an agent
ods stack up --profile full --json

# Inspect, follow one service, restart the services only
ods stack status --json
ods stack logs api --follow
ods stack restart

# Stop the services and keep the containers, or stop both
ods stack stop
ods stack down

# See what a profile would run
ods stack plan --profile full

# List every stack on the machine, and stop the ones whose worktree is gone
ods stack ls --all
ods stack down --project fast-mode-93732ec3
ods stack prune

# Also stop isolated stacks with no work in their worktree for 6 hours
ods stack prune --idle 6h --yes

object-store migrate - Move a Dev MinIO's Files to the Object Store

The dev stack runs the object store (SeaweedFS) only: ods compose dev keeps MinIO at zero replicas and points the app at the object store, and ods env drops S3_LEGACY_ENDPOINT_URL. A checkout that used MinIO before the object store still has its files in the <project>_minio_data volume. This command moves them across once and leaves MinIO stopped, so the app writes to one store only.

ods object-store migrate

It starts MinIO on a free port and retires it with the app's legacy copy, run from backend with .vscode/.env loaded: every object is copied (a multitenant checkout keeps its file records in tenant schemas), a quiet minute confirms nothing still writes to MinIO alone, and the retired marker stops running backend processes from using it. It then drops S3_LEGACY_ENDPOINT_URL from .vscode/.env and stops MinIO. The infra stack must be running (ods compose dev --infra). A failed copy leaves MinIO running and .vscode/.env untouched, so fix the cause and rerun; ods compose dev --infra --down stops it too.

Flags:

Flag Default Description
--keep-minio false Leave MinIO running afterwards

web - Run Frontend Scripts

On macOS or Linux, use ods web dev for a frontend-only change with a healthy API already running. It resolves the selected project's managed API and starts Next.js in the foreground. It fails if the API is unavailable. Start a full stack first in that case. Keep the terminal open while testing. Ctrl-C stops a newly launched preview. With a matching frontend already running in this checkout, the command attaches instead. Ctrl-C then only detaches. The reused API keeps running in either case. stack status reports stack services, excluding standalone previews. On Windows, this command uses the portable foreground launcher and configured API connection variables instead of managed API discovery and attachment.

Other scripts run from web/package.json without changing directories. Build and test commands keep their package-script behavior.

ods web <script> [args...]

Script names are available via shell completion (for supported shells via ods completion), and are read from web/package.json.

Examples:

# Start the Next.js dev server
ods web dev

# Run web lint task
ods web lint

# Forward extra args to the script
ods web test --watch

test - Run Go tests

Run the ODS, CLI, or Terraform-provider Go tests without changing directories. For frontend tests, use ods web test. Run backend tests with pytest.

ods test <suite|path> [args...]

The first argument is a suite name or a path inside a suite. A path selects the suite that covers it, so you can pass a file straight from your editor. All later arguments go to the suite's test runner.

Suite Aliases Directory Runner
ods tools/ods go test
cli cli go test
terraform tf terraform-provider-onyx go test
microvm microvm go test

The Go suites run with -race, the same as pr-golang-tests.yml. A runner that takes packages rather than files, such as go test, runs the package that holds a file argument. <file>::<TestName> runs one test.

Examples:

# Run a whole module
ods test ods

# Run one package, one file's package, or one test
ods test tools/ods/internal/testsuite
ods test tools/ods/internal/testsuite/testsuite_test.go
ods test tools/ods/internal/testsuite/testsuite_test.go::TestResolveGoTargets

# Forward arguments to go test
ods test cli -run TestChat -v

coverage - Measure Go Coverage Against a Baseline

Measure Go statement coverage per package and hold it against a committed baseline, so coverage can go up but not down.

ods coverage <suite|module-dir> [flags]

The baseline is a .coverage-baseline.yaml at the module root recording each package's floor. --check fails when a package drops below its floor, which is what pr-golang-tests.yml runs on every PR. After adding tests, --update raises the floors.

The floors are the gate, but they are not always a good comparison: they go stale, so the report shows gains the current change never made. Give --base a commit and the report compares against the coverage snapshot of that commit instead. A PR then sees only what it changed.

Coverage is measured per package with go test -coverprofile, so a package's number counts only its own tests. That is a number the package's owner can act on; a cross-package -coverpkg total would credit a package for statements its own tests never assert on.

The suites are the same Go modules ods test knows: ods, cli, terraform and microvm. A module directory such as tools/ods is accepted in place of a suite name, which is what CI passes.

Flags:

Flag Default Description
--check false Fail when a package drops below its baseline floor
--update false Rewrite the baseline from this run
--profile Keep the coverage profile at this path (for go tool cover)
--from-profile Report from this coverage profile instead of running the tests
--html Render the profile as a browsable page at this path
--markdown Write the changed packages as a markdown table at this path, for a PR comment
--tolerance 0.1 Percentage points a package may drop below its floor without failing
--base Report against the coverage snapshot of this commit instead of the floors
--publish false Record this run as the snapshot of HEAD (needs AWS credentials)
--snapshot-bucket onyx-playwright-artifacts S3 bucket that holds the snapshots

Examples:

# Report where each package stands
ods coverage ods

# Fail on a regression (what CI runs)
ods coverage ods --check

# Record today's numbers as the new floors
ods coverage ods --update

# Compare your branch against main (fetch first, so origin/main is current)
git fetch origin
ods coverage ods --base origin/main

# Keep the profile and browse the uncovered lines
ods coverage ods --profile /tmp/cover.out
go tool cover -html=/tmp/cover.out

Comparing against the base

A snapshot records the exact per-package statement counts of one commit. Each snapshot is a YAML object in S3 at s3://<bucket>/coverage/<module>/<commit sha>.yaml, where the module directory keeps its shape with / replaced by -: tools/ods becomes tools-ods. Runs on main and on release/** write them with --publish, which needs AWS credentials, refuses a dirty tree, and only records a fully successful run.

--base <commit-ish> resolves the base commit first: the merge base of that revision and HEAD when there is one, which is the fork point of your branch, else the revision itself. That is what CI passes, where the given SHA is already the base. The command then walks the first-parent history from the base, at most 25 commits, and reports against the first snapshot it finds. It logs the distance when the snapshot is not on the base commit itself.

With a snapshot, the report column reads Base instead of Floor. Without one, or when the revision cannot be fetched, the command prints a warning and reports against the floors, which is the behavior without --base.

--base never changes what the check does. The committed floors stay the only gate.

Raising the baseline

The gate never fails on an improvement, so a baseline goes stale as tests are added. ods coverage ods reports how many packages have risen; commit the gain with --update so the new level becomes the floor.

pr-golang-tests.yml runs ods coverage <module> --check for every Go module. Without a baseline the tests still run and the report prints, but nothing is gated. A module opts into the gate by committing a baseline, so cli and terraform-provider-onyx join by running ods coverage <suite> --update once.

CI measures and reports in two steps. The first runs the check with --profile and no AWS credentials: the test code comes from the PR, and a process can read the environment it starts with. The second step gets credentials and reports from that profile with --from-profile. A PR run adds --base <base sha>. A merge queue run on main, and a push to a release/** branch, add --publish instead, so the commit that lands gets its snapshot. A fork PR cannot assume the AWS role, so it reads no snapshot and falls back to the floors. After this change lands, run the workflow once by hand (workflow_dispatch on main) to publish the first snapshots.

Against a base, a module without a baseline still reports what moved, so cli and terraform-provider-onyx can now appear in the PR comment. The check still gates nothing for them.

In CI, each module's --markdown report goes to the job summary, and its --html page is uploaded as an artifact and published to the reports bucket. One PR comment, updated in place, lists the modules where a package moved, each with a link to its page.

Floors are rounded down to one decimal, and a package may sit --tolerance below its floor without failing. That absorbs the jitter from suites that depend on ports or timing; a real regression is far larger.

The package floors are the gate. The module total is reported with its delta but never fails the check: a package added without tests, or a well-covered package deleted, moves the total without any package regressing.

type-coverage - Measure Type Coverage Against a Baseline

Measure type coverage per directory and hold it against a committed baseline. Type coverage is the share of identifiers whose type is not any. Each type cast (x as T or <T>x) and each non-null assertion (x!) also counts as one uncovered item. as const and as unknown do not count, because they do not override the checker.

ods type-coverage <checker> [flags]

The only checker is typescript (alias ts), which measures web/. Python is not supported yet, because ty does not report types.

ods web types:check type-checks web/ with the TypeScript 7 API. From the same program, it counts the identifiers in each file. A type error fails the command before the coverage is compared. The count does not include tests: tests/ and __tests__/ directories, and *.test.* and *.spec.* files. Tests are still type-checked. This command groups the files into directories three levels deep, such as src/app/admin, and compares each directory with its floor in web/.type-coverage-baseline.yaml. The flags and the baseline format are the same as for ods coverage.

The default tolerance is 0, because the measurement does not change between runs. The TypeScript 7 API is marked unstable, so a TypeScript upgrade can move the floors. After an upgrade, run --update.

Flags:

Flag Default Description
--check false Fail when a directory drops below its baseline floor
--update false Rewrite the baseline from this run
--output Keep the per-file counts as JSON at this path
--markdown Write the changed directories as a markdown table at this path, for a PR comment
--tolerance 0 Percentage points a directory may drop below its floor without failing

Examples:

# Report where each directory stands
ods type-coverage ts

# Fail on a regression (what CI runs)
ods type-coverage ts --check

# Record the new floors after you remove `any` types
ods type-coverage ts --update

# Type-check and print the total only
ods web types:check

The typescript-check pre-commit hook runs --check when a .ts or .tsx file in web/ changes. pr-quality-checks.yml runs the same hook on every PR.

dev - Devcontainer Management

Manage the Onyx devcontainer. Also available as ods dc.

Requires the devcontainer CLI (bun install -g @devcontainers/cli).

ods dev <subcommand>

Subcommands:

  • up - Start the devcontainer (pulls the image if needed)
  • into - Open a zsh shell inside the running devcontainer
  • exec - Run an arbitrary command inside the devcontainer
  • restart - Remove and recreate the devcontainer
  • rebuild - Pull the latest published image and recreate
  • stop - Stop the running devcontainer

The devcontainer image is published to onyxdotapp/onyx-devcontainer and referenced by tag in .devcontainer/devcontainer.json — no local build needed.

Examples:

# Start the devcontainer
ods dev up

# Open a shell
ods dev into

# Run a command
ods dev exec -- bun test

# Restart the container
ods dev restart

# Pull latest image and recreate
ods dev rebuild

# Stop the container
ods dev stop

# Same commands work with the dc alias
ods dc up
ods dc into

db - Database Administration

Manage PostgreSQL database dumps, restores, and migrations.

ODS targets the selected project's exact Postgres or API container. It does not fall back to a legacy container or another project's image. Local migrations use the container's actual published Postgres port, overriding stale saved values. An explicit POSTGRES_HOST stays an explicit network target. Dump, restore, and drop reject network targets because these commands do not implement host clients. An explicit project that conflicts with the host target also fails. For migrations, an explicit loopback host and port are matched to their actual managed database owner. Another checkout cannot bypass ownership checks by specifying that owner's localhost port.

Database operations use the shared state and project locks. Mutating commands refuse a project owned by another managed checkout. Drop and restore prompts identify the selected project and container before changing data. Stop managed services before running ods db upgrade or ods db downgrade. Use ods stack up to check revisions and stop services only when an upgrade is pending. Restore errors return failure. SQL restores stop at the first SQL error. Dump and restore remove their temporary container files on success or failure. Dump output names ending in .sql or .dump must match --format.

ods db <subcommand>

Subcommands:

  • dump - Create a database dump
  • restore - Restore from a dump
  • upgrade/downgrade - Run database migrations
  • drop - Drop a database

Run ods db --help for detailed usage.

openapi - OpenAPI Schema Generation

Generate OpenAPI schemas and client code.

ods openapi all

check-lazy-imports - Verify Lazy Import Compliance

Check that specified modules are only lazily imported (used for keeping backend startup fast).

ods check-lazy-imports

check-getattr - Forbids the getattr Builtin

Checks that backend Python code does not reference the getattr builtin, which hides attribute access from the type checker. Genuinely dynamic lookups are suppressed inline with # ods: ignore[getattr] plus a brief justification. String literal contents and comments never match; replacement fields inside f-strings are scanned as code.

ods check-getattr [paths...]

--annotate appends the ignore marker to every violating line (baseline maintenance).

fmt - Format Sources

Also available as ods format.

fmt tf - Format Terraform

Rewrite Terraform files into the canonical HCL style. Also available as ods fmt terraform.

ods fmt tf [paths...]

This applies the same formatter as terraform fmt, so the output matches terraform byte for byte, but no terraform binary is needed. A file that does not parse is reported and left alone.

Files and directories may be given to limit the run. With no arguments, the whole repository is scanned. Vendored trees (.terraform, node_modules, .venv) are always skipped.

Flags:

Flag Default Description
--check false Report unformatted files without rewriting them

Examples:

# Format every .tf file in the repository
ods fmt tf

# Format one subtree
ods fmt tf deployment/terraform

# Report unformatted files, change nothing
ods fmt tf --check

The command exits non-zero when a file was rewritten or failed to parse, which is how the terraform-fmt pre-commit hook gates a commit.

lint - Run Linters

lint tf - Check Published Terraform

Check published Terraform modules for values that must stay internal. Also available as ods lint terraform.

ods lint tf [paths...]

The modules under deployment/terraform are published, but they stay in sync with the infrastructure Onyx runs. That makes it easy to carry an internal value across by accident -- an office IP in a variable default is the case this check was written for.

The check looks for objective patterns only:

Rule Fails on
access_key AWS access key ids (AKIA…, ASIA…)
email Email addresses
cidr Routable IPv4 CIDRs; private and reserved ranges pass
account_id 12-digit values that look like AWS account ids

It cannot screen for customer names, because listing them here would leak them; that stays a review step.

Add a trailing # public-safe: ok comment to accept a specific line.

Files and directories may be given to limit the check. With no arguments, deployment/terraform is scanned.

Examples:

# Check all published modules
ods lint tf

# Check one subtree
ods lint tf deployment/terraform/modules/aws

# Check a single file
ods lint tf deployment/terraform/modules/aws/vpc/main.tf

audit - Audit Dependencies for Vulnerabilities

Install the audit extra first. The scanner is about 50 MB, most of the download, so it ships as a separate onyx-devtools-audit wheel that provides the ods-audit binary. ods audit forwards to it and prints an install hint when it is missing.

# Install alongside ods
uv tool install 'onyx-devtools[audit]'

# Or run it without installing (how CI runs the gate)
uv run --with 'onyx-devtools[audit]' ods audit

ods-audit takes the same arguments, so ods audit --python and ods-audit --python are the same command.

Scan the JavaScript (bun.lock) and Python (uv.lock) lockfiles via osv-scanner (vendored as a library, no external binary required) and open GitHub Dependabot security alerts for known vulnerabilities. With no selector flags, all sources are audited.

Accepted advisories are suppressed via an allowlist fetched from S3 at runtime (s3://onyx-internal-tools/audit/ignores.json by default), so a release can be unblocked without a code change. The command exits non-zero when an unignored finding at or above --fail-on (default critical) remains, which is how it gates deploys.

ods audit [--web] [--python] [--dependabot] [--format text[,json][,sarif]] [--fail-on critical|high|moderate|low] [--ignore-url s3://...]

--format takes a comma-separated list. The machine-readable formats (json, sarif) are written to stdout, while the human-readable text report is written to stderr when combined with one of them. This lets a single run produce a SARIF file for upload and a readable report in the log: ods audit --format=sarif,text > audit.sarif sends SARIF to the file and the report (plus, when the gate fails, a runbook explaining how to resolve or suppress each finding) to the terminal. A lone format always goes to stdout, so --format=sarif > audit.sarif is unchanged. At most one machine-readable format may be requested.

Examples:

# Audit everything; fail on unignored criticals
ods audit

# Only the Python lockfile
ods audit --python

# Emit a SARIF report (used by the nightly GitHub code-scanning job)
ods audit --python --format=sarif > audit.sarif

# SARIF to a file for upload, readable report to the log (used by CI gates)
ods audit --format=sarif,text > audit.sarif

# Every tracked bun.lock and uv.lock, not just the root and web ones
ods audit --all-lockfiles --web --python

Rust-built PyPI tools in images

The image scanner records the uv binary as the crates.io crate uv, but uv advisories are filed on PyPI. ods audit image also matches each such crate as the PyPI package of the same version. Add other tools of this kind to pypiToolsFromCrates in internal/audit/image.go.

Audit software installed outside package managers

Use ods audit image IMAGE --sbom /path/in/image.cdx.json for a required CycloneDX inventory. ODS scans the inventory with pinned Grype and combines its findings with the OSV image report. Docker must be available. Missing inventory, empty inventory, and scanner errors fail the audit. Use --sbom-only when a job checks only software from supplemental inventories. The same advisory exceptions, JSON/SARIF reports, and CVE alerts apply to both scanners.

Deployment opts into update deadlines with --update-policy s3://onyx-internal-tools/audit/updates.json. PR audits and CVE collection scan vulnerabilities without reading update policy. Missing or invalid policy fails deployment audits. This state is separate from advisory exceptions. It records an emergency minimum and each release's first observation. Routine updates warn after 24 hours and block after 72 hours. Emergency minimums block immediately. Stale upstream observations warn without resetting recorded deadlines. Image scans leave freshness checks disabled unless --update-policy is supplied. ods audit gate includes freshness checks as part of its deployment checks.

CVE Tracking owns policy observation and S3 writes. Its manual minimum input raises Chrome's emergency minimum. It saves this minimum before upstream discovery, preserving release timestamps even if discovery fails. It checks main and supported release branches. Update Sandbox Browser opens or updates pin PRs for stale branches. CI builds the audit binary from source. Installed ODS commands receive these features through the normal devtools release.

Audit the Craft Firecracker guest kernel and Firecracker

A scanner cannot read a bare vmlinux or the Firecracker binaries. ods audit craft-fc reads the KERNEL_TAG and FC_VERSION pins in deployment/craft-fc/Dockerfile.artifacts and matches them against advisory feeds:

  • The guest kernel is an amazonlinux/linux tag: the AL2023 kernel package source (kernel6.18-<version>) or a microvm-kernel tag. Each Amazon Linux 2023 advisory (ALAS) for the same kernel series, fixed in a newer package than the pin, is a finding.
  • Firecracker is matched against the GitHub security advisories of firecracker-microvm/firecracker.

The allowlist, report formats and --fail-on work as for ods audit image. A feed that cannot be read fails the command. Set GH_TOKEN to raise the GitHub API rate limit.

ods audit craft-fc --fail-on=high

Checking a release branch before a tag

ods audit gate runs the deploy gate on the checked-out tree: the lockfiles, Dependabot alerts, pinned Actions, and the OS layer each shipped image carries (the pinned runtime base for web and model-server, the apt stages of backend and the sandbox built from their Dockerfiles). A critical here is the one that would fail the tag build, so run it on the release branch at the commit you are about to tag. It scans the same hardened bases CI ships, so it needs Docker, docker login dhi.io, and a signed-in gh for the Dependabot alerts; every scan is strict, so a source it cannot read fails the gate.

git switch release/v4.7
ods audit gate && git tag v4.7.11 && git push origin v4.7.11

Tracking issues for blocking findings

ods audit alert keeps one open GitHub issue (label cve-alert) per package and branch with a blocking finding. It reads the JSON results of earlier scans, applies the allowlist, opens an issue for each newly blocking package, updates the issue when the package gains an advisory, and closes the issues of packages that no longer block. It prints the alerts that need announcing as JSON, including any still labelled cve-alert-pending from a run that never announced them. The CVE Alerts workflow runs it daily and after a failed deploy audit, opens a fix PR when a pin applies, and posts each alert to Slack with the details in a thread.

ods audit --web --python --ignore-url "" --format=json > deps.json
ods audit image docker.io/onyxdotapp/onyx-backend:edge --ignore-url "" --format=json > backend.json
ods audit alert --results deps.json --results backend.json --dry-run

Pass the results of every scan: a package missing from all of them counts as resolved and has its issue closed. When a scan was skipped, pass --keep-open so no issue closes. --scope <branch> (default main) labels the issues with the branch the results came from, so a package's issues on main and on a release branch stay apart.

Managing the allowlist

Suppress a reviewed-and-accepted advisory so it stops blocking the gate:

# Interactive editor (add/edit/delete rows, then upload after a confirmation)
ods audit ignore

# Non-interactive add of a single suppression (a --reason is required)
ods audit ignore add GHSA-xxxx-xxxx-xxxx --ecosystem npm \
  --reason "not reachable in our usage" --expires 2026-09-01

ods audit ignore add stamps added_by from your git email, shows a diff, and uploads the updated allowlist to S3 after a confirmation prompt (--yes skips it). Suppress only advisories you've assessed — the allowlist gates every deploy.

The allowlist is a JSON document of the form:

{
  "ignores": [
    {
      "id": "GHSA-xxxx-xxxx-xxxx",
      "ecosystem": "npm",
      "reason": "not reachable in our usage",
      "added_by": "you@onyx.app",
      "expires": "2026-09-01"
    }
  ]
}

id matches a finding's id or any of its aliases (case-insensitive); ecosystem and expires are optional (an expired entry stops suppressing).

run-ci - Run CI on Fork PRs

Pull requests from forks don't automatically trigger GitHub Actions for security reasons. This command creates a branch and PR in the main repository to run CI on a fork's code.

ods run-ci <pr-number>

Example:

# Run CI for PR #7353 from a fork
ods run-ci 7353

# Create a replacement PR for making edits and merging
ods run-ci 7353 --for-edits

--for-edits derives the editable branch from the contributor's branch. It preserves feat/, fix/, refactor/, and chore/ prefixes; otherwise it adds chore/. For example, fix/search-timeout becomes fix/search-timeout-pr-7353-edits. It also keeps the contributor's original PR description and cherry-pick selection, and marks the new PR as superseding the original. The replacement PR should be merged and the original PR closed without merging. It cannot be combined with --rerun, which would discard edits made on the replacement branch. The command also refuses to overwrite an existing replacement PR or remote branch.

cherry-pick - Backport Commits to Release Branches

Cherry-pick one or more commits to release branches and automatically create PRs. Cherry-pick PRs created by this command are labeled cherry-pick 🍒.

ods cherry-pick <commit-sha> [<commit-sha>...] [--release <version>]

Examples:

# Cherry-pick a single commit (auto-detects release version)
ods cherry-pick abc123

# Cherry-pick to a specific release
ods cherry-pick abc123 --release 2.5

# Cherry-pick to multiple releases
ods cherry-pick abc123 --release 2.5 --release 2.6

# Cherry-pick multiple commits
ods cherry-pick abc123 def456 ghi789 --release 2.5

screenshot-diff - Visual Regression Testing

Compare Playwright screenshots against baselines and generate visual diff reports. Baselines are stored per-project and per-revision in S3:

s3://<bucket>/baselines/<project>/<rev>/

This allows storing baselines for main, release branches (release/2.5), and version tags (v2.0.0) side-by-side. Revisions containing / are sanitised to - in the S3 path (e.g. release/2.5 → release-2.5).

ods screenshot-diff <subcommand>

Subcommands:

  • compare - Compare screenshots against baselines and generate a diff report
  • upload-baselines - Upload screenshots to S3 as new baselines

The --project flag provides sensible defaults so you don't need to specify every path. When set, the following defaults are applied:

Flag Default
--baseline s3://onyx-playwright-artifacts/baselines/<project>/<rev>/
--current web/output/screenshots/
--output web/output/screenshot-diff/<project>/index.html
--rev main

The S3 bucket defaults to onyx-playwright-artifacts and can be overridden with the PLAYWRIGHT_S3_BUCKET environment variable.

compare Flags:

Flag Default Description
--project Project name (e.g. admin); sets sensible defaults
--rev main Revision baseline to compare against
--from-rev Source (older) revision for cross-revision comparison
--to-rev Target (newer) revision for cross-revision comparison
--baseline Baseline directory or S3 URL (s3://...)
--current Current screenshots directory or S3 URL (s3://...)
--output screenshot-diff/index.html Output path for the HTML report
--threshold 0.2 Per-channel pixel difference threshold (0.0–1.0)
--max-diff-ratio 0.01 Max diff pixel ratio before marking as changed

upload-baselines Flags:

Flag Default Description
--project Project name (e.g. admin); sets sensible defaults
--rev main Revision to store the baseline under
--dir Local directory containing screenshots to upload
--dest S3 destination URL (s3://...)
--delete false Delete S3 files not present locally

Examples:

# Compare local screenshots against the main baseline (default)
ods screenshot-diff compare --project admin

# Compare against a release branch baseline
ods screenshot-diff compare --project admin --rev release/2.5

# Compare two revisions directly (both sides fetched from S3)
ods screenshot-diff compare --project admin --from-rev v1.0.0 --to-rev v2.0.0

# Compare with explicit paths
ods screenshot-diff compare \
  --baseline ./baselines \
  --current ./web/output/screenshots/ \
  --output ./report/index.html

# Upload baselines for main (default)
ods screenshot-diff upload-baselines --project admin

# Upload baselines for a release branch
ods screenshot-diff upload-baselines --project admin --rev release/2.5

# Upload baselines for a version tag
ods screenshot-diff upload-baselines --project admin --rev v2.0.0

# Upload with delete (remove old baselines not in current set)
ods screenshot-diff upload-baselines --project admin --delete

The compare subcommand writes a summary.json alongside the report with aggregate counts (changed, added, removed, unchanged). The HTML report is only generated when visual differences are detected.

trace - View Playwright Traces from CI

Download Playwright trace artifacts from a GitHub Actions run and open them with playwright show-trace. Traces are only generated for failing tests (retain-on-failure).

ods trace [run-id-or-url]

The run can be specified as a numeric run ID, a full GitHub Actions URL, or omitted to find the latest Playwright run for the current branch.

Flags:

Flag Default Description
--branch, -b Find latest run for this branch
--pr Find latest run for this PR number
--project, -p Filter to a specific project (admin, exclusive, lite)
--list, -l false List available traces without opening
--no-open false Download traces but don't open them

When multiple traces are found, an interactive picker lets you select which traces to open. Use arrow keys or j/k to navigate, space to toggle, a to select all, n to deselect all, and enter to open. Falls back to a plain-text prompt when no TTY is available.

Downloaded artifacts are cached in /tmp/ods-traces/<run-id>/ so repeated invocations for the same run are instant.

Examples:

# Latest run for the current branch
ods trace

# Specific run ID
ods trace 12345678

# Full GitHub Actions URL
ods trace https://github.com/onyx-dot-app/onyx/actions/runs/12345678

# Latest run for a PR
ods trace --pr 9500

# Latest run for a specific branch
ods trace --branch main

# Only download admin project traces
ods trace --project admin

# List traces without opening
ods trace --list

deploy edge - Deploy main or a Branch to Edge

Build images from origin/main or a pushed branch, then deploy them to the edge environment.

ods deploy edge [flags]

Without --ref, or with --ref main, the command force-pushes the edge tag to origin/main. With --ref <branch or commit>, it pushes the tag dev-build-<branch>-<short-sha> on that commit. The tag starts deployment.yml, which publishes the images to Docker Hub. When the build succeeds, the command dispatches the configured deploy workflow with version_tag=<tag>.

A dev-build- tag never moves. If the tag already points at the commit, the command waits for its build and does not push again. If the tag points at another commit, the command stops.

On first run, the command asks for the deploy target repo and the workflow filename, and saves them in the ods config file.

Flag Default Description
--ref main Branch name or full commit SHA on origin to build
--tag Tag for --ref instead of the derived tag; must start dev-build-, and must not contain cloud or end in -dev
--dry-run false Resolve the ref and tag only; push and dispatch nothing
--yes false Skip the confirmation prompt
--no-wait-deploy false Do not wait for the deploy workflow to finish
--verify false Run pre-push hooks when you push the tag
--target-repo Deploy workflow repo (owner/name); overrides saved config
--target-workflow Deploy workflow filename; overrides saved config
# Build and deploy origin/main
ods deploy edge

# Build and deploy a pushed branch
ods deploy edge --ref user/my-feature

# Show the tag, push nothing
ods deploy edge --ref user/my-feature --dry-run

Testing Changes Locally (Dry Run)

Both run-ci and cherry-pick support --dry-run to test without making remote changes:

# See what would happen without pushing
ods run-ci 7353 --dry-run
ods cherry-pick abc123 --release 2.5 --dry-run

Upgrading

To upgrade the stable version, upgrade it as you would any other requirement.

Building from source

Generally, go build . or go install . are sufficient.

go build . will output a tools/ods/ods binary which you can call normally,

./ods --version

while go install . will output to your GOPATH (defaults ~/go/bin/ods),

~/go/bin/ods --version

Typically, GOPATH is added to your shell's PATH, but this may be confused easily during development with the pip version of ods installed in the Onyx venv.

To build the wheel,

uv build --wheel

To build and install the wheel,

uv pip install .

Build constraints

The release workflows build every wheel against tools/requirements/build-constraints.txt, shared by cli, tools/ods and tools/ods-audit. They pass it as UV_BUILD_CONSTRAINT with UV_REQUIRE_HASHES, so the build environment (hatchling, go-bin, manygo and their dependencies) is pinned and verified.

A plain local uv build resolves those dependencies freely. Set the same variables to build against the pinned closure:

UV_BUILD_CONSTRAINT="$(git rev-parse --show-toplevel)/tools/requirements/build-constraints.txt" \
  UV_REQUIRE_HASHES=true GOTOOLCHAIN=local \
  uv build --wheel

tools/requirements/build-constraints.txt is compiled from its .in by the pip-compile pre-commit hook, so prek run pip-compile --all-files refreshes it. To upgrade a pinned build dependency, edit build-constraints.in and the matching [build-system] requires in all three pyproject.toml files; the build-constraints-drift hook fails if they disagree.

go-bin ships the Go toolchain used to compile the binary. Bumping Go means moving it everywhere at once: the go directive in every go.mod, the golang image tag and digest in cli/Dockerfile and microvm/Dockerfile, the setup-go and GO_VERSION pins across .github/workflows/, GO_VERSION and both tarball checksums in .devcontainer/Dockerfile, the go-bin pin in all three pyproject.toml files and in tools/requirements/build-constraints.in, the compiled build-constraints.txt, and the golangci-lint language_version in .pre-commit-config.yaml. A new Go release can need a newer golangci-lint, so run the hook on a file in each module after the bump.

Deploy

Releases are deployed automatically when git tags prefaced with ods/ are pushed to GitHub.

ods release ods calculates and pushes the next tag for you,

ods release ods              # bumps the patch version
ods release ods --bump minor
ods release ods --version 0.14.0
ods release ods --dry-run    # computes the version, tags nothing

The workflow also opens a PR moving every onyx-devtools== pin in the repo to the new version, so no follow-up commit is needed.

See also, .github/workflows/release-devtools.yml.

Metadata

Release files for onyx-devtools 0.13.17

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Built distributions (wheels)

Table of built distributions (wheels) for onyx-devtools 0.13.17
File Actions
onyx_devtools-0.13.17-py3-none-win_arm64.whl Python 3 none Windows ARM64 Details for onyx_devtools-0.13.17-py3-none-win_arm64.whl
onyx_devtools-0.13.17-py3-none-win_amd64.whl Python 3 none Windows x86-64 Details for onyx_devtools-0.13.17-py3-none-win_amd64.whl
onyx_devtools-0.13.17-py3-none-manylinux_2_17_x86_64.whl Python 3 none Linux glibc 2.17+ x86-64 Details for onyx_devtools-0.13.17-py3-none-manylinux_2_17_x86_64.whl
onyx_devtools-0.13.17-py3-none-manylinux_2_17_aarch64.whl Python 3 none Linux glibc 2.17+ ARM64 Details for onyx_devtools-0.13.17-py3-none-manylinux_2_17_aarch64.whl
onyx_devtools-0.13.17-py3-none-macosx_11_0_arm64.whl Python 3 none macOS 11.0+ ARM64 Details for onyx_devtools-0.13.17-py3-none-macosx_11_0_arm64.whl
onyx_devtools-0.13.17-py3-none-macosx_10_12_x86_64.whl Python 3 none macOS 10.12+ x86-64 Details for onyx_devtools-0.13.17-py3-none-macosx_10_12_x86_64.whl

Total release size: 39.6 MB

Release files / onyx_devtools-0.13.17-py3-none-win_arm64.whl

Download URL onyx_devtools-0.13.17-py3-none-win_arm64.whl
Size 6.3 MB
Tags Python 3 Windows ARM64
SHA-256 checksum
How to use checksums
da60fa347f4c367310754047d802d01f2b66e09e80875ee0b22695e8e2897230
BLAKE2b-256 checksum
How to use checksums
5312eac919de06ffb287c39da1ecd4dfe59e90413b9effefe3bc5fadf920c6ed
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.13.8 {"installer":{"name":"uv","version":"0.13.8","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Release files / onyx_devtools-0.13.17-py3-none-win_amd64.whl

Download URL onyx_devtools-0.13.17-py3-none-win_amd64.whl
Size 7.0 MB
Tags Python 3 Windows x86-64
SHA-256 checksum
How to use checksums
2ff06ce3a1a9d8bbf5bcc5ad7c5899de42fc1b1d2ae030349eabd48372db7ca9
BLAKE2b-256 checksum
How to use checksums
eed90d824bcc57f470dc114f6a6a4a66e40a49e14f5afd9aded0e9acf6160fd9
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.13.8 {"installer":{"name":"uv","version":"0.13.8","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Release files / onyx_devtools-0.13.17-py3-none-manylinux_2_17_x86_64.whl

Download URL onyx_devtools-0.13.17-py3-none-manylinux_2_17_x86_64.whl
Size 6.9 MB
Tags Linux glibc 2.17+ x86-64 Python 3
SHA-256 checksum
How to use checksums
a3f02d0140c9ad8ef3f5a80e49fd3f14a8d4a142cadaed5ea868d1c68399136c
BLAKE2b-256 checksum
How to use checksums
cd6af3f81a0bdb3acfa5347efc1f2114e3654843e4429364c5cb6638dbbc528b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.13.8 {"installer":{"name":"uv","version":"0.13.8","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Release files / onyx_devtools-0.13.17-py3-none-manylinux_2_17_aarch64.whl

Download URL onyx_devtools-0.13.17-py3-none-manylinux_2_17_aarch64.whl
Size 6.2 MB
Tags Linux glibc 2.17+ ARM64 Python 3
SHA-256 checksum
How to use checksums
0b5d2cde8432f17d837d0c2516e83b5af6432a727a7018d1625dc86703df6d0f
BLAKE2b-256 checksum
How to use checksums
917247b22cdd9a3c534b7c9b3baddc63578fe7b4c8320a3489cc6240c9aa7f03
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.13.8 {"installer":{"name":"uv","version":"0.13.8","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Release files / onyx_devtools-0.13.17-py3-none-macosx_11_0_arm64.whl

Download URL onyx_devtools-0.13.17-py3-none-macosx_11_0_arm64.whl
Size 6.4 MB
Tags Python 3 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
7c7edc256bd076c54c29ed1601a9b0b1027f456ec7cee9007e5b09cb2d871672
BLAKE2b-256 checksum
How to use checksums
9a213b6b6daaf2099edfc15bd54c8be1c9f8a4fc0f22a14acac6d58c4a2fc542
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.13.8 {"installer":{"name":"uv","version":"0.13.8","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Release files / onyx_devtools-0.13.17-py3-none-macosx_10_12_x86_64.whl

Download URL onyx_devtools-0.13.17-py3-none-macosx_10_12_x86_64.whl
Size 6.9 MB
Tags Python 3 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
9b25ba510a56eb8366f3dce0af4929b724097897bdcf2b1acbe9422d8aea87e2
BLAKE2b-256 checksum
How to use checksums
818e7232ab28e919f37e4a314ca529a7bd4338a70bb4643cff5a04fe8ea534f4
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.13.8 {"installer":{"name":"uv","version":"0.13.8","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Security for onyx-devtools 0.13.17

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.13.17 This release

6 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page