# Entry Point for the oblien/openship Application: Monorepo Structure Explained

> Discover the primary entry point for the oblien/openship application at apps/api/src/index.ts. Learn how it initializes Hono server and WebSocket handlers for seamless operation.

- Repository: [oblien/openship](https://github.com/oblien/openship)
- Tags: internals
- Published: 2026-07-29

---

**The primary entry point for the oblien/openship application is [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts), which initializes the Hono HTTP server and WebSocket handlers, while the Dashboard UI launches separately from `apps/dashboard/standalone-server.mjs` when running the full stack via Turbo.**

OpenShip is a monorepo that orchestrates multiple services—including an API, Dashboard UI, and CLI—using **Turbo**. When you start the application, the root [`package.json`](https://github.com/oblien/openship/blob/main/package.json) triggers concurrent processes that boot each service through their respective entry points.

## Understanding the OpenShip Monorepo Architecture

The repository uses a workspace-based structure managed by Turbo. The top-level [`package.json`](https://github.com/oblien/openship/blob/main/package.json) defines the orchestration layer that determines which services start and in what order.

According to the source code, the root [`package.json`](https://github.com/oblien/openship/blob/main/package.json) contains the following start script:

```json
{
  "scripts": {
    "start": "turbo run start --filter=@repo/api --filter=@repo/dashboard --concurrency=10"
  }
}

```

Running `npm run start` or `bun run start` executes Turbo with filters for the `@repo/api` and `@repo/dashboard` packages, launching both services simultaneously with a concurrency limit of 10.

## Primary Entry Point: The API Service (apps/api/src/index.ts)

The core backend entry point resides in [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts). This file is responsible for booting the HTTP server, configuring runtime adapters, attaching WebSocket support, and registering graceful shutdown hooks.

In [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts), the application imports the Hono app instance and starts the server:

```typescript
import { app } from "./app";

// Configuration and server startup logic
serve();

```

The `serve()` function listens on the configured port and initializes the connection handlers. This makes [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts) the first piece of code executed when the API service starts, establishing the runtime environment before handling incoming requests.

## Dashboard Entry Point: apps/dashboard/standalone-server.mjs

While the API handles backend logic, the Dashboard UI runs as a separate service with its own entry point at `apps/dashboard/standalone-server.mjs`.

This file creates a **Vite**-powered development or production server that serves the React frontend. It also configures proxy settings to forward API calls to the backend service, ensuring seamless communication between the frontend and the Hono server running from [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts).

## How to Start the Application

You have several options for launching OpenShip depending on whether you need the full stack or individual services.

**Starting the full application:**

```bash

# Install dependencies (once)

bun install

# Start both API and Dashboard via Turbo

npm run start

# or

bun run start

```

**Running only the API service:**

```bash
cd apps/api
bun run build-release   # Compile TypeScript

node dist/index.js      # Runs the compiled entry point

```

**Running only the Dashboard UI:**

```bash
cd apps/dashboard
bun run dev   # Starts Vite dev server from standalone-server.mjs

```

## CLI Entry Point (Optional)

For command-line operations, OpenShip provides a CLI tool with its entry point at [`apps/cli/cli.ts`](https://github.com/oblien/openship/blob/main/apps/cli/cli.ts). This file contains utilities for deployment and management tasks, though it runs independently of the main API and Dashboard services.

## Summary

- The **entry point for the oblien/openship application** backend is [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts), which boots the Hono server and WebSocket support.
- The **Dashboard UI** starts from `apps/dashboard/standalone-server.mjs` using Vite.
- The **root [`package.json`](https://github.com/oblien/openship/blob/main/package.json)** orchestrates both services via Turbo using the `start` script with filters for `@repo/api` and `@repo/dashboard`.
- The **CLI** entry point is located at [`apps/cli/cli.ts`](https://github.com/oblien/openship/blob/main/apps/cli/cli.ts) for management utilities.
- You can run services individually by navigating to their respective directories and using `bun run` commands.

## Frequently Asked Questions

### What is the main entry point for the OpenShip backend?

The main entry point is [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts). This file imports the Hono application instance from `./app` and calls `serve()` to start the HTTP server, initialize WebSocket handlers, and register graceful shutdown hooks according to the source code.

### How do I start only the API service without the Dashboard?

Navigate to the `apps/api` directory and run `bun run build-release` followed by `node dist/index.js`. This compiles the TypeScript source and executes the same entry point used in production without launching the Dashboard UI.

### What server framework does OpenShip use for the API?

OpenShip uses **Hono** as its web framework. The entry point at [`apps/api/src/index.ts`](https://github.com/oblien/openship/blob/main/apps/api/src/index.ts) imports the configured Hono app and wraps it with the `serve()` function to handle HTTP and WebSocket connections.

### Where is the entry point for the OpenShip CLI?

The CLI entry point is located at [`apps/cli/cli.ts`](https://github.com/oblien/openship/blob/main/apps/cli/cli.ts). This file provides command-line utilities for deployment and management tasks, operating independently from the main API and Dashboard services.