@bpinhosilva/agent-orchestrator 1.0.0-alpha.26 → 1.0.0-alpha.28

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+# [1.0.0-alpha.28](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.27...v1.0.0-alpha.28) (2026-04-04)
+
+
+### Features
+
+* **migrations:** add initial schema with users, providers, models, agents, projects, tasks ([e08e338](https://github.com/bpinhosilva/agent-orchestrator/commit/e08e3388794e8a556be3584daedd30252a8904fb))
+* **migrations:** db schema ([a0a98b7](https://github.com/bpinhosilva/agent-orchestrator/commit/a0a98b725e09f6d3a9a8fc2305704772195fe2d8))
+
+# [1.0.0-alpha.27](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.26...v1.0.0-alpha.27) (2026-04-04)
+
+
+### Features
+
+* update default port to 15789 for production, enhance migration handling, and refactor env ([e59ba31](https://github.com/bpinhosilva/agent-orchestrator/commit/e59ba3105c5ce7367281bf3ee637bcc3bc124dcc))
+* update mascot image format and adjust display size in README ([6779313](https://github.com/bpinhosilva/agent-orchestrator/commit/6779313a26a6906ecb47a8819789dc8312f3d6fc))
+
 # [1.0.0-alpha.26](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.25...v1.0.0-alpha.26) (2026-04-04)
 
 

package/README.md

@@ -1,387 +1,278 @@
 # Agent Orchestrator
 
-[![CI](https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/ci.yml/badge.svg)](https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/ci.yml)
-[![Release](https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/release.yml/badge.svg)](https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/release.yml)
-[![Gitleaks](https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/gitleaks.yml/badge.svg)](https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/gitleaks.yml)
-[![Socket Badge](https://socket.dev/api/badge/npm/package/@bpinhosilva/agent-orchestrator)](https://socket.dev/npm/package/@bpinhosilva/agent-orchestrator)
-
-Agent Orchestrator is an open-source project designed to manage and orchestrate AI agents using both back-end services and front-end applications. It provides an automated agentic execution environment where you can create multiple agent profiles (e.g., Head Agent, Researcher, CMO) and delegate tasks to them through automated workflows.
-
-## Features (In Progress & Planned)
-- **Agent Delegation**: Delegate tasks to specialized AI agents.
-- **Multi-Provider Support**: Google Gemini and Anthropic Claude providers.
-- **Job Scheduler**: Create and schedule recurring agentic tasks.
-- **Workflow Engine**: Drag-and-drop workflow builder supporting triggers, agent chaining, and outputs.
-- **Agent Capabilities**: File reading/writing, web search, email capabilities, and image generation.
-- **Role-Based Access Control**: Admin and member roles with project-level membership.
-- **TUI/CLI Tooling**: CLI executables to manage the installation and local agent configuration.
-
-## Architecture
-- **Backend Framework**: NestJS 11 + TypeScript 5
-- **Frontend SPA**: React (built separately, served as static files)
-- **Database**: PostgreSQL (production) / SQLite (development)
-- **Testing**: Jest (TDD Approach with Unit & E2E)
-- **Architecture**: 3-Tier (Controller → Service → Repository)
+<p align="center">
+  <img src="https://raw.githubusercontent.com/bpinhosilva/agent-orchestrator/main/docs/assets/lupy-mascot.webp" alt="Lupy, the Agent Orchestrator mascot" width="500" />
+</p>
 
-## Prerequisites
-- [Node.js](https://nodejs.org/) (v24+)
-- [Docker](https://www.docker.com/) and Docker Compose (optional, for the containerized stack)
-- A [Google Gemini API Key](https://aistudio.google.com/) or [Anthropic API Key](https://console.anthropic.com/)
+<p align="center"><em>Lupy, the project mascot, inspired by Bruno's dog and companion of 10 years.</em></p>
 
-## Quick Start
+<p align="center">
+  <a href="https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/ci.yml"><img src="https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
+  <a href="https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/gitleaks.yml"><img src="https://github.com/bpinhosilva/agent-orchestrator/actions/workflows/gitleaks.yml/badge.svg" alt="Gitleaks" /></a>
+  <a href="https://socket.dev/npm/package/@bpinhosilva/agent-orchestrator"><img src="https://socket.dev/api/badge/npm/package/@bpinhosilva/agent-orchestrator" alt="Socket Badge" /></a>
+</p>
 
-### 1. Choose an installation path
+Agent Orchestrator is an open-source platform for managing AI agents, tasks, and project-scoped automation across multiple model providers. It combines a NestJS API, a React dashboard, a packaged CLI/runtime, and Docker deployment options for both local use and production-style environments.
 
-**Option A: install the packaged CLI**
+## Current capabilities
 
-```bash
-npm install -g @bpinhosilva/agent-orchestrator
-agent-orchestrator --help
-```
+- Multi-provider agent execution with Google Gemini and Anthropic Claude
+- Agent profiles with provider/model selection
+- Project management with project membership and RBAC
+- Task execution plus recurring scheduling
+- File upload and artifact-backed task workflows
+- Packaged CLI/runtime for setup, run, status, logs, stop, and migrate
+- React dashboard served by the backend or packaged runtime
 
-**Option B: run from a source checkout**
+## Planned direction
 
-```bash
-git clone <repo> && cd agent-orchestrator
-npm install
-npm rebuild
-npm run build:all
-```
+- Richer workflow orchestration and agent chaining
+- Broader agent tool integrations
+- Expanded runtime and deployment ergonomics
 
-> **Note**: The project uses `ignore-scripts=true` in `.npmrc` for supply chain security. After installing dependencies from source, run `npm rebuild` to compile native modules (bcrypt, sqlite3).
+## Architecture at a glance
 
-### 2. Configure the runtime
+| Area | Stack |
+| --- | --- |
+| Backend | NestJS 11 + TypeScript 5 |
+| Frontend | React SPA |
+| Database | PostgreSQL (production) / SQLite via `better-sqlite3` (local/runtime) |
+| ORM | TypeORM |
+| Auth | JWT access/refresh tokens via httpOnly cookies |
+| Packaging | npm package with bundled backend, CLI, and UI assets |
 
-**CLI-driven setup (recommended for local/runtime installs)**
+## Prerequisites
 
-```bash
-agent-orchestrator setup
-```
+- [Node.js](https://nodejs.org/) 24 or newer
+- npm
+- [Docker](https://www.docker.com/) and Docker Compose (optional)
+- At least one provider API key to execute agents:
+  - [Google Gemini API key](https://aistudio.google.com/)
+  - [Anthropic API key](https://console.anthropic.com/)
 
-The CLI writes `${AGENT_ORCHESTRATOR_HOME}/.env` with user-only permissions (`0600`), can run migrations, and can seed an admin user. It also supports non-interactive setup:
+## Quick start
 
-```bash
-agent-orchestrator setup \
-  --yes \
-  --db-type postgres \
-  --database-url postgresql://orchestrator:orchestrator_password@localhost:5433/agent_orchestrator \
-  --provider gemini \
-  --gemini-key your-gemini-api-key \
-  --skip-admin-setup
-```
+Choose the path that matches how you want to use the project:
 
-**Manual `.env` setup**
+- **Packaged CLI/runtime**: quickest way to run the app locally as an installed tool
+- **Source checkout**: best path for development and contributing
 
-Create a `.env` file in the project root (or set `AGENT_ORCHESTRATOR_HOME` to point to a directory containing `.env`):
+### Option A: packaged CLI/runtime
 
 ```bash
-# Required
-JWT_SECRET="at-least-32-characters-long-secret-key"
+npm install -g @bpinhosilva/agent-orchestrator
+agent-orchestrator setup
+agent-orchestrator run
+agent-orchestrator status
+```
 
-# AI Providers (at least one required for agent functionality)
-GEMINI_API_KEY="your-gemini-api-key"
-ANTHROPIC_API_KEY="your-anthropic-api-key"
+`setup` can create the runtime `.env`, run migrations, seed an admin user, and prompt you to apply pending migrations after package updates. `run` does not upgrade the database automatically. The default runtime home is `~/.agent-orchestrator`, or `${AGENT_ORCHESTRATOR_HOME}` if you set it explicitly.
 
-# Optional
-PORT=3000                           # Server port (default: 3000)
-NODE_ENV=development                # development | production | test
-DATABASE_URL=                       # PostgreSQL connection string (omit for SQLite)
-ALLOWED_ORIGINS=http://localhost:5173,http://localhost:3000
-SCHEDULER_ENABLED=true              # Enable/disable task scheduler CRON
-DB_LOGGING=false                    # Enable TypeORM query logging
-SERVE_STATIC_UI=true                # Set false when the UI is served by a separate container/proxy
-CHECK_PENDING_MIGRATIONS_ON_STARTUP=false
-```
+For deeper CLI usage, see [docs/CLI.md](docs/CLI.md).
 
-### 3. Set Up the Database
+### Option B: source checkout
 
-**Option A: SQLite (Development — zero config)**
+```bash
+git clone https://github.com/bpinhosilva/agent-orchestrator.git
+cd agent-orchestrator
+npm install
+npm rebuild
+npm run build:all
+```
 
-SQLite is used automatically when `DATABASE_URL` is not set. The database file is created at `local.sqlite` in the project root (or `$AGENT_ORCHESTRATOR_HOME/local.sqlite`).
+> **Note**: The repository uses `ignore-scripts=true` in `.npmrc` for supply-chain hardening. After `npm install`, run `npm rebuild --ignore-scripts=false` so native modules such as `bcrypt` and `better-sqlite3` are actually compiled.
 
-**Option B: PostgreSQL (Production / Docker)**
+If you want to use the packaged CLI behavior from a source checkout, run the built entrypoint directly:
 
 ```bash
-# Start only PostgreSQL
-docker compose up -d db
-
-# Set the connection string
-export DATABASE_URL="postgresql://orchestrator:orchestrator_password@localhost:5433/agent_orchestrator"
+node dist/cli/index.js --help
 ```
 
-Then run migrations and seed the admin user:
+## Configure the runtime
 
-```bash
-# Apply database migrations
-npm run migration:run
+The app loads configuration from:
 
-# Create the initial admin user (interactive prompt)
-npm run seed:admin
-```
+- `${AGENT_ORCHESTRATOR_HOME}/.env` when `AGENT_ORCHESTRATOR_HOME` is set
+- `.env` in the project/package root otherwise
 
-### 4. Run the Application
+Example `.env`:
 
 ```bash
-# Packaged/runtime CLI
-agent-orchestrator run
-agent-orchestrator status
-agent-orchestrator logs --lines 50
-agent-orchestrator stop
+# Required
+JWT_SECRET="replace-with-a-secret-at-least-32-characters-long"
 
-# Development (API + UI with hot reload)
-npm run dev
+# Provider keys (optional until you want to execute agents)
+GEMINI_API_KEY=""
+ANTHROPIC_API_KEY=""
 
-# Or API only in watch mode
-npm run start:dev
+# Database
+DB_TYPE=sqlite
+DATABASE_URL=
 
-# Production build
-npm run build
-npm run start:prod
+# Runtime
+PORT=15789
+NODE_ENV=production
+ALLOWED_ORIGINS=http://localhost:5173,http://localhost:3000
+SCHEDULER_ENABLED=true
+DB_LOGGING=false
+SERVE_STATIC_UI=true
+CHECK_PENDING_MIGRATIONS_ON_STARTUP=false
 ```
 
-The dashboard is available at `http://localhost:3000` and the API at `http://localhost:3000/api/v1/`.
+## Database setup
 
-### 5. Run with Docker
+### SQLite
 
-The repository now includes three compose entrypoints:
+SQLite is the default local/runtime option when `DATABASE_URL` is not set. The database file lives at:
 
-- `docker-compose.yml` — production-like stack with **PostgreSQL + distroless API + Caddy UI**
-- `docker-compose.dev.yml` — development stack with hot reload for API and UI
-- `docker-compose-test.yml` — containerized integration stack for migration, CLI, API, and UI checks
+- `local.sqlite` in the project/package root, or
+- `${AGENT_ORCHESTRATOR_HOME}/local.sqlite` when runtime home is set
 
-All Docker entrypoints read from the repository-root `.env` file. For the Docker flows, the most relevant variables are:
-
-```bash
-JWT_SECRET="at-least-32-characters-long-secret-key"
-POSTGRES_USER=orchestrator
-POSTGRES_PASSWORD=orchestrator_password
-POSTGRES_DB=agent_orchestrator
-POSTGRES_PORT=5433
-POSTGRES_TEST_DB=agent_orchestrator_test
-POSTGRES_TEST_PORT=5434
-GEMINI_API_KEY=
-ANTHROPIC_API_KEY=
-```
+### PostgreSQL
 
-#### Production-like Docker stack
+Use PostgreSQL by setting `DATABASE_URL` or `DB_TYPE=postgres`:
 
 ```bash
-# Build and start PostgreSQL + API + UI
-npm run docker:up
-
-# The API will refuse to start until migrations are applied
-docker compose run --rm api dist/cli/index.js migrate --yes
-
-# Stop the stack
-npm run docker:down
+export DATABASE_URL="postgresql://orchestrator:orchestrator_password@localhost:5433/agent_orchestrator"
 ```
 
-- UI: `https://localhost` or `https://agent-orchestrator.localhost`
-- API: `http://localhost:3000/api/v1`
-
-The API container does **not** serve the SPA in Docker mode. The UI is served by **Caddy**, which also proxies `/api/*` traffic to the API container so the browser can use the same origin for UI + API.
+### Initialize the schema
 
-The UI container uses **Caddy** with `tls internal`, so HTTPS works locally without an external CA. Browsers will still warn until you trust Caddy's local root certificate on your host machine. You can copy it out of the container with:
+Run migrations before the first app start:
 
 ```bash
-docker compose cp ui:/data/caddy/pki/authorities/local/root.crt ./caddy-local-root.crt
+npm run migration:run
 ```
 
-After trusting that certificate in your OS/browser trust store, local HTTPS becomes trusted as well.
-
-#### Development Docker stack
+Create the initial admin user if you want to sign in through the dashboard:
 
 ```bash
-npm run docker:dev
-
-# Stop the dev stack
-docker compose -f docker-compose.dev.yml down
+npm run seed:admin
 ```
 
-- UI dev server: `http://localhost:5173`
-- API: `http://localhost:3000/api/v1`
-- PostgreSQL: `localhost:5433`
+If you use the packaged CLI, `agent-orchestrator setup` can perform both steps for you.
 
-The dev stack disables bundled UI serving in the API container and points the Vite dev proxy at the `api` service over the Docker network.
+## Run the application
 
-#### Docker integration / end-to-end stack
-
-Use the test compose file when you want to exercise migration behavior, CLI commands, API startup, and the UI together:
+### Local development
 
 ```bash
-# Start only the database first
-docker compose -f docker-compose-test.yml up -d db
-
-# Verify pending migrations block API startup
-docker compose -f docker-compose-test.yml up api
-
-# Apply migrations with the packaged CLI runtime
-docker compose -f docker-compose-test.yml run --rm migrate
-
-# Then bring up the full app stack
-docker compose -f docker-compose-test.yml up ui api
-
-# Run ad hoc CLI checks
-docker compose -f docker-compose-test.yml run --rm cli dist/cli/index.js status
-
-# Tear the test stack down
-docker compose -f docker-compose-test.yml down -v
+npm run dev
 ```
 
-The test stack is designed for:
+That starts:
 
-- verifying that pending migrations block API startup,
-- applying migrations through the packaged CLI/runtime path,
-- checking UI reachability through Caddy,
-- exercising future CLI-driven Docker behaviors without depending on the local SQLite test path.
-
-## Database Management
-
-The project uses [TypeORM](https://typeorm.io/) migrations to manage schema changes. **Never rely on `synchronize: true`** — it is disabled in all environments.
+- UI dev server: `http://localhost:5173`
+- API: `http://localhost:3000/api/v1`
+- Swagger UI: `http://localhost:3000/api` (non-production only)
+- Health endpoint: `http://localhost:3000/health`
 
-### Migration Commands
+If you only want the API in watch mode:
 
 ```bash
-# Generate a new migration from entity changes
-npm run typeorm -- migration:generate src/migrations/DescriptiveName
-
-# Apply all pending migrations
-npm run migration:run
-
-# Revert the last applied migration
-npm run migration:revert
-
-# Drop the entire database schema (use with caution!)
-npm run schema:drop
+npm run start:dev
 ```
 
-### Migration Workflow
-
-1. Modify your entity files in `src/`
-2. Generate a migration: `npm run typeorm -- migration:generate src/migrations/YourMigrationName`
-3. Review the generated file in `src/migrations/`
-4. Apply it: `npm run migration:run`
-5. Verify with tests: `npm run test:all`
-
-### Seeding
+### Packaged/runtime mode
 
 ```bash
-# Create the initial admin user
-npm run seed:admin
+agent-orchestrator run
+agent-orchestrator status
+agent-orchestrator logs --lines 50
+agent-orchestrator stop
 ```
 
-This creates a user with the `admin` role. All subsequent users registered via `POST /auth/register` (admin-only endpoint) default to `member` role.
+When running the packaged app or a production build with static UI enabled, the dashboard is served from `http://localhost:15789` by default.
 
-## Deployment
+## Docker
 
-### Production Checklist
+The repository ships three Compose entrypoints:
 
-1. **Database**: Use PostgreSQL — set `DATABASE_URL` environment variable
-2. **Migrations**: Run `npm run migration:run` before starting the app
-3. **Environment**:
-   - `NODE_ENV=production` — disables Swagger UI and enables secure cookies
-   - `JWT_SECRET` — strong secret, minimum 32 characters
-   - `ALLOWED_ORIGINS` — comma-separated list of allowed CORS origins (required in production)
-4. **Build**: Run `npm run build` to compile TypeScript and bundle the UI
-5. **Start**: `npm run start:prod` (or `node dist/main.js`)
+All Compose stacks now require the database variables in the project `.env` file: `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB`, and `POSTGRES_TEST_DB` for the integration stack.
 
-### Docker
+| File | Purpose |
+| --- | --- |
+| `docker-compose.yml` | Production-style stack with PostgreSQL, API, and Caddy-served UI |
+| `docker-compose.dev.yml` | Development stack with API hot reload and Vite UI dev server |
+| `docker-compose.test.yml` | Integration stack for migration, CLI/runtime, API, and UI checks |
+
+### Production-style stack
 
 ```bash
-# Production-like stack
 npm run docker:up
-
-# Apply migrations with the packaged runtime inside the API container
 docker compose run --rm api dist/cli/index.js migrate --yes
-
-# Stop the stack
-npm run docker:down
 ```
 
-The API container is configured to **fail fast when migrations are pending**. This keeps schema changes explicit instead of silently mutating the database during startup.
+Endpoints:
 
-This behavior is controlled by `CHECK_PENDING_MIGRATIONS_ON_STARTUP=true` in the Docker API service. Docker mode also sets `SERVE_STATIC_UI=false` so the backend does not try to serve bundled frontend assets.
-
-### Updating an Existing Deployment
+- UI: `https://localhost` or `https://agent-orchestrator.localhost`
+- API: `https://localhost/api/v1` or `https://agent-orchestrator.localhost/api/v1`
 
-1. Pull the latest code
-2. Install dependencies: `npm ci && npm rebuild`
-3. Build: `npm run build`
-4. Run new migrations: `npm run migration:run`
-5. Restart the application
+In this stack the UI is served by **Caddy**, not by the Nest app. Docker explicitly sets `SERVE_STATIC_UI=false` so the backend only serves the API.
 
-## Testing
+### Development stack
 
 ```bash
-# Unit tests
-npm test
-
-# Unit tests in watch mode
-npm run test:watch
-
-# E2E tests
-npm run test:e2e
-
-# All tests (unit + UI + E2E)
-npm run test:all
-
-# Test coverage
-npm run test:cov
-
-# Run a single test file
-npm test -- src/auth/auth.service.spec.ts
-
-# Run tests matching a name pattern
-npm test -- --testNamePattern="should validate email"
+npm run docker:dev
 ```
 
-## Security
+Endpoints:
 
-### Authentication & Authorization
+- UI: `http://localhost:5173`
+- API: `http://localhost:3000/api/v1`
+- PostgreSQL: `localhost:5433`
 
-- **JWT-based authentication** with httpOnly cookie transport (no tokens in response bodies)
-- **Role-Based Access Control (RBAC)**: `admin` and `member` roles
-  - **Admin**: Full access to all resources
-  - **Member**: Access scoped to projects they own or are members of
-- **Project membership**: Many-to-many model with `owner` and `member` roles per project
-- **Rate limiting**: 60 req/min globally, 5 req/min on auth endpoints
-- All routes protected by default — use `@Public()` decorator for public endpoints
+### Integration stack
 
-### Supply Chain Protection
+Use `docker-compose.test.yml` when you want to exercise migration behavior, packaged CLI/runtime flows, API startup, and UI reachability together.
 
-- `.npmrc` hardened: registry pinned to `registry.npmjs.org`, install scripts disabled
-- `lockfile-lint` validates lockfile integrity in CI and pre-commit hooks
-- `npm audit signatures` checks package provenance in CI
-- [Socket.dev](https://socket.dev) monitors dependencies for supply chain risks
+```bash
+npm run docker:test
+docker compose -f docker-compose.test.yml --profile tools run --rm migrate
+docker compose -f docker-compose.test.yml --profile tools run --rm cli
+```
 
-### Additional Hardening
+Endpoints:
 
-- Helmet.js security headers with Content Security Policy
-- CORS restricted to `ALLOWED_ORIGINS` (deny-all in production without explicit config)
-- Swagger UI disabled in production
-- File upload validation: MIME type allowlist + 10MB size limit
-- Input length limits on all text fields via class-validator
+- UI: `https://localhost:8444` or `https://agent-orchestrator.localhost:8444`
+- API: `https://localhost:8444/api/v1` or `https://agent-orchestrator.localhost:8444/api/v1`
 
-## API Usage
+## Development workflow
 
-**Endpoint**: `POST /api/v1/agents/process`
-**Payload**:
-```json
-{
-  "input": "Write a short poem about automation."
-}
-```
+| Task | Command |
+| --- | --- |
+| Start API + UI | `npm run dev` |
+| Start API only | `npm run start:dev` |
+| Lint API + UI | `npm run lint:all` |
+| Run API + UI + E2E tests | `npm run test:all` |
+| Run coverage | `npm run test:cov` |
+| Run E2E tests | `npm run test:e2e` |
+| Build backend + UI package output | `npm run build:all` |
+| Apply migrations | `npm run migration:run` |
 
-## Contributing
+## Auth and access model
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+- Access and refresh tokens are issued by the auth service and transported via **httpOnly cookies**
+- System roles are **`admin`** and **`user`**
+- Project membership roles are **`owner`** and **`member`**
+- Routes are protected by default; use `@Public()` for public endpoints
+- Global throttling defaults to `60/min`, with stricter limits on auth endpoints
 
-## Additional Documentation
+## Useful docs
 
 - [CLI reference](docs/CLI.md)
 - [CI/CD pipeline](docs/CI_CD.md)
 - [Release process](docs/RELEASE.md)
+- [Contributing guide](CONTRIBUTING.md)
+
+## Troubleshooting
+
+- **Native module errors after install**: run `npm rebuild`
+- **`JWT_SECRET` rejected**: it must be at least 32 characters
+- **Agent execution fails immediately**: confirm `GEMINI_API_KEY` and/or `ANTHROPIC_API_KEY` are set
+- **Schema/startup issues**: run `npm run migration:run`
+- **Need to undo the latest migration**: run `npm run migration:revert`
 
 ## License
 
-See [LICENSE](LICENSE) for details.
+See [LICENSE](LICENSE).

package/dist/cli/index.js

@@ -54,11 +54,12 @@ const crypto = __importStar(require("crypto"));
 const child_process_1 = require("child_process");
 const bcrypt = __importStar(require("bcrypt"));
 const typeorm_1 = require("../config/typeorm");
+const port_defaults_1 = require("../config/port.defaults");
 const migration_state_1 = require("../database/migration-state");
 const avatar_constants_1 = require("../users/avatar.constants");
 const user_entity_1 = require("../users/entities/user.entity");
 let program = new commander_1.Command();
-const DEFAULT_PORT = '3000';
+const DEFAULT_PORT = `${port_defaults_1.RUNTIME_DEFAULT_PORT}`;
 const PACKAGE_JSON_PATH = path.join(path.resolve(__dirname, '..', '..'), 'package.json');
 const MAIN_FILE = path.join(path.resolve(__dirname, '..', '..'), 'dist/main.js');
 const UI_INDEX_FILE = path.join(path.resolve(__dirname, '..', '..'), 'dist/ui/index.html');
@@ -472,6 +473,7 @@ function buildEnvContent(currentEnv, basicConfig, databaseUrl, geminiKey, anthro
         PORT: basicConfig.port,
         DB_TYPE: basicConfig.dbType,
         DB_LOGGING: `${basicConfig.dbLogging}`,
+        CHECK_PENDING_MIGRATIONS_ON_STARTUP: currentEnv.CHECK_PENDING_MIGRATIONS_ON_STARTUP || 'true',
         JWT_SECRET: jwtSecret,
     };
     if (databaseUrl) {
@@ -491,6 +493,7 @@ function buildEnvContent(currentEnv, basicConfig, databaseUrl, geminiKey, anthro
         'PORT',
         'DB_TYPE',
         'DB_LOGGING',
+        'CHECK_PENDING_MIGRATIONS_ON_STARTUP',
         'DATABASE_URL',
         'GEMINI_API_KEY',
         'ANTHROPIC_API_KEY',

package/dist/config/env.validation.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.envValidationSchema = void 0;
 const Joi = __importStar(require("joi"));
 exports.envValidationSchema = Joi.object({
-    PORT: Joi.number().default(3000),
+    PORT: Joi.number().port().optional(),
     DATABASE_URL: Joi.string().optional(),
     DB_TYPE: Joi.string().valid('postgres', 'sqlite').optional(),
     JWT_SECRET: Joi.string().min(32).required(),

package/dist/config/port.defaults.d.ts

@@ -0,0 +1,3 @@
+export declare const DEV_DEFAULT_PORT = 3000;
+export declare const RUNTIME_DEFAULT_PORT = 15789;
+export declare function getDefaultPort(nodeEnv?: string): number;

package/dist/config/port.defaults.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUNTIME_DEFAULT_PORT = exports.DEV_DEFAULT_PORT = void 0;
+exports.getDefaultPort = getDefaultPort;
+exports.DEV_DEFAULT_PORT = 3000;
+exports.RUNTIME_DEFAULT_PORT = 15789;
+function getDefaultPort(nodeEnv) {
+    return nodeEnv === 'production' ? exports.RUNTIME_DEFAULT_PORT : exports.DEV_DEFAULT_PORT;
+}

package/dist/config/typeorm.d.ts

@@ -1,5 +1,8 @@
 import { DataSource, DataSourceOptions } from 'typeorm';
 import { ConfigService } from '@nestjs/config';
+export type RuntimeDbType = 'postgres' | 'sqlite';
+export declare function resolveDataSourceType(dbType: RuntimeDbType): 'postgres' | 'better-sqlite3';
+export declare function isSqliteDriver(type: DataSourceOptions['type']): boolean;
 export declare const getTypeOrmConfig: (configService: ConfigService) => DataSourceOptions;
 export declare const createDataSource: () => DataSource;
 declare const _default: DataSource;