Scripts Reference

ElyOS is a Bun workspaces based monorepo. The root package.json contains main commands that invoke workspace package scripts.

Monorepo Structure

elyos-core/
├── package.json              # Root scripts (using bun --filter)
├── apps/
│   └── web/
│       └── package.json      # @elyos/core scripts
└── packages/
    └── database/
        └── package.json      # @elyos/database scripts

Important: Root scripts can be run from anywhere in the monorepo. Scripts specific to apps/web must be run from the apps/web directory.

Development

`bun app:dev`

Location: Root Runs: apps/web → dev script

Starts SvelteKit dev server with local .env file (without Varlock).

bun app:dev

What it does:

Loads ../../.env file (root .env)
Starts Vite dev server (http://localhost:5173)
Hot module replacement (HMR) enabled

When to use: Local development, fast iteration.

`bun app:dev:varlock`

Location: Root Runs: apps/web → dev:varlock script

Starts SvelteKit dev server with Varlock (Infisical secrets).

bun app:dev:varlock

What it does:

Varlock loads secrets from Infisical
Validates environment variables
Starts Vite dev server

When to use: Testing configuration similar to production.

Build and Preview

`bun app:build`

Location: Root Runs: apps/web → build script

Creates production build.

bun app:build

What it does:

SvelteKit production build (vite build)
Adapter-node output: apps/web/build/
Static assets: apps/web/build/client/

`bun app:preview`

Location: apps/web Runs: preview script

Starts production build locally.

cd apps/web
bun preview

What it does:

Starts Express + Socket.IO server (server.js)
Serves built application
Port: process.env.PORT or 3000

Prerequisite: Run bun app:build first.

Type Checking

`bun app:check`

Location: Root Runs: apps/web → check script

TypeScript and Svelte type checking.

bun app:check

What it does:

svelte-kit sync — generates SvelteKit types
svelte-check — checks Svelte components
tsc — TypeScript type checking

When to use: Before commit, in CI/CD.

Database

`bun db:init`

Location: Root Runs: packages/database → db:init script

First startup — complete database initialization.

bun db:init

What it does:

db:generate — generate migrations
db:migrate — run migrations
db:seed — load seed data

When to use: First installation or after complete reset.

`bun db:generate`

Location: Root Runs: packages/database → db:generate script

Generate Drizzle migrations from schema changes.

bun db:generate

What it does:

Compares src/schemas/ files with database
Generates SQL migration files in drizzle/ folder

When to use: After schema modification (new table, column, index, etc.).

`bun db:migrate`

Location: Root Runs: packages/database → db:migrate script

Run pending migrations.

bun db:migrate

What it does:

Runs all new migrations from drizzle/ folder
Updates __drizzle_migrations table

`bun db:seed`

Location: Root Runs: packages/database → db:seed script

Load seed data.

bun db:seed

What it does:

Runs seed scripts from src/seeds/ folder
Creates admin user (based on ADMIN_USER_EMAIL)
Loads default applications, roles, etc.

`bun db:studio`

Location: Root Runs: packages/database → db:studio script

Open Drizzle Studio.

bun db:studio

What it does:

Starts Drizzle Studio web interface
Opens in browser: https://local.drizzle.studio
Visual database browser and editor

`bun db:reset`

Location: Root Runs: packages/database → db:reset script

Complete database reset.

bun db:reset

What it does:

Drops all tables
Re-runs migrations
Loads seed data

Warning: All data is lost!

Docker

`bun docker:db`

Location: Root

Start PostgreSQL container only.

bun docker:db

What it does:

Starts postgres service
Port: 5432
Data: docker/postgres-data/ (persistent)

When to use: Local development, database only.

`bun docker:up`

Location: Root

Start full stack (ElyOS + PostgreSQL).

bun docker:up

What it does:

Builds Docker image
Starts app and postgres services
Detached mode (-d)

Available at: http://localhost:3000

`bun docker:down`

Location: Root

Stop all containers.

bun docker:down

What it does:

Stops and removes containers
Volumes remain (data not lost)

`bun docker:logs`

Location: Root

Follow container logs.

bun docker:logs

What it does:

Real-time container logs
Ctrl+C to exit

Testing

`bun test`

Location: apps/web

Run all tests once.

cd apps/web
bun test

What it does:

Vitest unit tests
--run mode (not watch)

`bun test:watch`

Location: apps/web

Run tests in watch mode.

cd apps/web
bun test:watch

What it does:

Re-runs tests on file changes
Interactive mode

`bun test:pbt`

Location: apps/web

Run property-based tests only.

cd apps/web
bun test:pbt

What it does:

Runs tests containing “Property”
fast-check based tests

Code Quality

`bun lint`

Location: apps/web

Prettier and ESLint check.

cd apps/web
bun lint

What it does:

prettier --check . — formatting check
eslint . — code quality check

`bun format`

Location: apps/web

Automatic code formatting.

cd apps/web
bun format

What it does:

prettier --write . — formats all files

Common Workflows

First Startup

# 1. Dependencies
bun install

# 2. Env file
cp .env.example .env
# Edit .env file

# 3. Database
bun docker:db
bun db:init

# 4. Dev server
bun app:dev

Schema Modification

# 1. Modify packages/database/src/schemas/ files

# 2. Generate migration
bun db:generate

# 3. Run migration
bun db:migrate

# 4. (Optional) Re-run seed
bun db:seed

Production Build Testing

# 1. Build
bun app:build

# 2. Preview
cd apps/web
bun preview

Docker Deployment

# 1. Env file (bootstrap credentials only)
cp .env.example .env
# INFISICAL_CLIENT_ID and INFISICAL_CLIENT_SECRET

# 2. Start
bun docker:up

# 3. Logs
bun docker:logs

Next Steps

Environment Variables → — Varlock and Infisical
Database → — Drizzle ORM and migrations
Testing → — Unit and property-based tests