openship 0.1.0 → 0.1.1

package/apps/desktop/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "out",
+    "rootDir": "src",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "types": ["node"],
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false
+  },
+  "include": ["src/main/**/*.ts", "src/preload/**/*.ts"],
+  "exclude": ["node_modules", "dist", "out"]
+}

package/apps/web/.source/browser.ts

@@ -0,0 +1,13 @@
+// @ts-nocheck
+import { browser } from 'fumadocs-mdx/runtime/browser';
+import type * as Config from '../source.config';
+
+const create = browser<typeof Config, import("fumadocs-mdx/runtime/types").InternalTypeConfig & {
+  DocData: {
+  }
+}>();
+const browserCollections = {
+  blog: create.doc("blog", {"how-ai-builds-work.mdx": () => import("../content/blog/how-ai-builds-work.mdx?collection=blog"), "introducing-openship.mdx": () => import("../content/blog/introducing-openship.mdx?collection=blog"), "self-hosting-cost-breakdown.mdx": () => import("../content/blog/self-hosting-cost-breakdown.mdx?collection=blog"), }),
+  docs: create.doc("docs", {"api.mdx": () => import("../content/docs/api.mdx?collection=docs"), "cli.mdx": () => import("../content/docs/cli.mdx?collection=docs"), "first-deployment.mdx": () => import("../content/docs/first-deployment.mdx?collection=docs"), "index.mdx": () => import("../content/docs/index.mdx?collection=docs"), "installation.mdx": () => import("../content/docs/installation.mdx?collection=docs"), "quickstart.mdx": () => import("../content/docs/quickstart.mdx?collection=docs"), }),
+};
+export default browserCollections;

package/apps/web/.source/dynamic.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import { dynamic } from 'fumadocs-mdx/runtime/dynamic';
+import * as Config from '../source.config';
+
+const create = await dynamic<typeof Config, import("fumadocs-mdx/runtime/types").InternalTypeConfig & {
+  DocData: {
+  }
+}>(Config, {"configPath":"./source.config.ts","environment":"next","outDir":".source"}, {"doc":{"passthroughs":["extractedReferences"]}});

package/apps/web/.source/server.ts

@@ -0,0 +1,22 @@
+// @ts-nocheck
+import * as __fd_glob_9 from "../content/docs/quickstart.mdx?collection=docs"
+import * as __fd_glob_8 from "../content/docs/installation.mdx?collection=docs"
+import * as __fd_glob_7 from "../content/docs/index.mdx?collection=docs"
+import * as __fd_glob_6 from "../content/docs/first-deployment.mdx?collection=docs"
+import * as __fd_glob_5 from "../content/docs/cli.mdx?collection=docs"
+import * as __fd_glob_4 from "../content/docs/api.mdx?collection=docs"
+import { default as __fd_glob_3 } from "../content/docs/_meta.json?collection=docs"
+import * as __fd_glob_2 from "../content/blog/self-hosting-cost-breakdown.mdx?collection=blog"
+import * as __fd_glob_1 from "../content/blog/introducing-openship.mdx?collection=blog"
+import * as __fd_glob_0 from "../content/blog/how-ai-builds-work.mdx?collection=blog"
+import { server } from 'fumadocs-mdx/runtime/server';
+import type * as Config from '../source.config';
+
+const create = server<typeof Config, import("fumadocs-mdx/runtime/types").InternalTypeConfig & {
+  DocData: {
+  }
+}>({"doc":{"passthroughs":["extractedReferences"]}});
+
+export const blog = await create.docs("blog", "content/blog", {}, {"how-ai-builds-work.mdx": __fd_glob_0, "introducing-openship.mdx": __fd_glob_1, "self-hosting-cost-breakdown.mdx": __fd_glob_2, });
+
+export const docs = await create.docs("docs", "content/docs", {"_meta.json": __fd_glob_3, }, {"api.mdx": __fd_glob_4, "cli.mdx": __fd_glob_5, "first-deployment.mdx": __fd_glob_6, "index.mdx": __fd_glob_7, "installation.mdx": __fd_glob_8, "quickstart.mdx": __fd_glob_9, });

package/apps/web/.source/source.config.mjs

@@ -0,0 +1,20 @@
+// source.config.ts
+import { defineDocs, defineConfig, frontmatterSchema } from "fumadocs-mdx/config";
+import { z } from "zod";
+var docs = defineDocs({ dir: "content/docs" });
+var blog = defineDocs({
+  dir: "content/blog",
+  docs: {
+    schema: frontmatterSchema.extend({
+      date: z.string().optional(),
+      category: z.string().optional(),
+      author: z.string().optional()
+    })
+  }
+});
+var source_config_default = defineConfig();
+export {
+  blog,
+  source_config_default as default,
+  docs
+};

package/apps/web/Dockerfile

@@ -1,15 +1,13 @@
 # ─── Build stage ────────────────────────────────────────
-FROM node:20-alpine AS builder
-RUN corepack enable && corepack prepare pnpm@9.0.0 --activate
+FROM oven/bun:1 AS builder
 WORKDIR /app
 
-COPY pnpm-workspace.yaml pnpm-lock.yaml* package.json ./
-COPY tooling/ ./tooling/
+COPY package.json bun.lock pnpm-workspace.yaml ./
 COPY packages/ ./packages/
 COPY apps/web/ ./apps/web/
 
-RUN pnpm install --frozen-lockfile
-RUN pnpm run build --filter=openship-web...
+RUN bun install --frozen-lockfile
+RUN cd apps/web && bun run build
 
 # ─── Production stage ──────────────────────────────────
 FROM node:20-alpine AS runner

package/apps/web/content/blog/how-ai-builds-work.mdx

@@ -0,0 +1,55 @@
+---
+title: "How AI Builds Work in Openship"
+description: "A look under the hood at how Openship uses AI to detect frameworks, generate configs, and optimize builds automatically."
+date: "2026-03-08"
+category: "Engineering"
+author: "Openship Team"
+---
+
+# How AI Builds Work in Openship
+
+When you run `openship deploy`, a lot happens before your app goes live. Here's how the AI build system works.
+
+## Step 1: Framework detection
+
+Openship scans your project for signals:
+
+- `package.json` scripts and dependencies
+- Config files (`next.config.js`, `nuxt.config.ts`, `Cargo.toml`, etc.)
+- Dockerfile presence
+- Directory structure patterns
+
+This produces a confidence-scored framework match. If Openship detects Next.js with 95% confidence, it uses the Next.js build pipeline. If there's a Dockerfile, it uses that directly.
+
+## Step 2: Config generation
+
+Based on the detected framework, Openship generates:
+
+- **Build command** — `npm run build`, `go build`, etc.
+- **Start command** — `npm start`, `./server`, etc.
+- **Port mapping** — Detects which port your app listens on
+- **Environment variables** — Suggests required vars based on framework conventions
+
+You can override any of these in `openship.json`.
+
+## Step 3: Build optimization
+
+The AI layer optimizes the build:
+
+- **Layer caching** — Dependency layers are cached separately from source code
+- **Multi-stage builds** — Production images exclude dev dependencies
+- **Parallel builds** — Multi-service projects build concurrently
+
+## Step 4: Health checks
+
+After deployment, Openship verifies:
+
+- The container starts successfully
+- The health check endpoint responds
+- SSL is provisioned and valid
+
+If any check fails, the deployment is rolled back automatically.
+
+## What's next
+
+We're working on AI-powered diagnostics — when a build fails, Openship will analyze the error and suggest fixes. Stay tuned.

package/apps/web/content/blog/introducing-openship.mdx

@@ -0,0 +1,46 @@
+---
+title: "Introducing Openship: Deploy Anything, Own Everything"
+description: "We're launching Openship — an open-source, self-hostable deployment platform. Here's why we built it and what it can do."
+date: "2026-03-01"
+category: "Announcement"
+author: "Openship Team"
+---
+
+# Introducing Openship: Deploy Anything, Own Everything
+
+Today we're open-sourcing Openship — a deployment platform you can run on your own servers.
+
+## Why we built this
+
+Cloud platforms like Vercel and Netlify are great for getting started. But as your app grows, so does the bill. Metered CPU, per-seat pricing, bandwidth caps — it adds up fast. And when you want to leave, you realize your infrastructure is locked into their proprietary systems.
+
+We wanted something different:
+
+- **Self-hosted first** — Run on any Linux server. A $20/month VPS handles what costs $200+ on managed platforms.
+- **Open source** — MIT licensed. No black boxes, no vendor lock-in.
+- **AI-assisted** — Framework detection, build optimization, and configuration are handled automatically.
+
+## What you can deploy
+
+Openship supports any stack that runs in a container:
+
+- **Frontend frameworks** — Next.js, Nuxt, SvelteKit, Astro, Remix
+- **Backend** — Node.js, Python, Go, Rust, Ruby, PHP
+- **Databases** — Postgres, MySQL, Redis, MongoDB
+- **Full-stack** — Multi-service apps with shared networking
+
+## Getting started
+
+```bash
+curl -fsSL https://get.openship.io | sh
+cd your-project
+openship deploy
+```
+
+Three commands. That's it.
+
+## What's next
+
+We're working on load balancers, cluster management, private networking, and a built-in CI/CD pipeline. Check the [roadmap](/docs) for details.
+
+Star us on [GitHub](https://github.com/openshiporg/openship) and join the community.

package/apps/web/content/blog/self-hosting-cost-breakdown.mdx

@@ -0,0 +1,59 @@
+---
+title: "Self-Hosting vs. Managed Platforms: The Real Cost Breakdown"
+description: "We compared the actual cost of running a production Next.js app on Vercel, AWS, and a self-hosted Openship setup. The numbers might surprise you."
+date: "2026-03-05"
+category: "Guide"
+author: "Openship Team"
+---
+
+# Self-Hosting vs. Managed Platforms: The Real Cost Breakdown
+
+"Just use Vercel" is good advice — until your bill arrives. We ran the same Next.js app across three setups and tracked every cost for 30 days.
+
+## The test app
+
+A production Next.js 15 app with:
+- ~50 routes, ISR enabled
+- Postgres database
+- Redis for caching
+- ~100K monthly visitors
+- ~500GB bandwidth/month
+
+## The results
+
+| | Vercel Pro | AWS (ECS + RDS) | Openship (self-hosted) |
+|---|---|---|---|
+| Compute | $150/mo | $85/mo | $24/mo |
+| Database | $50/mo (Neon) | $45/mo | Included |
+| Bandwidth | $120/mo | $45/mo | Included |
+| SSL/Domains | Included | $1/mo | Included |
+| **Total** | **$320/mo** | **$176/mo** | **$24/mo** |
+
+The self-hosted Openship setup runs on a single Hetzner VPS (CPX31: 4 vCPU, 8GB RAM, 160GB SSD).
+
+## The trade-offs
+
+Managed platforms give you zero-ops. You push code, it deploys. That's real value.
+
+But Openship closes the gap significantly:
+- **AI handles config** — Build detection, Dockerfile generation, and SSL are automatic.
+- **One-command deploys** — `openship deploy` is just as fast.
+- **Built-in monitoring** — Logs, metrics, and alerts out of the box.
+
+The remaining trade-off is server maintenance — OS updates, disk space, uptime monitoring. For most teams, that's a few hours per month.
+
+## When to self-host
+
+Self-hosting makes sense when:
+- Your monthly bill exceeds ~$100 on managed platforms
+- You need data sovereignty or compliance
+- You want predictable, flat-rate pricing
+- You're deploying multiple apps (cost stays the same)
+
+## Try it
+
+```bash
+curl -fsSL https://get.openship.io | sh
+```
+
+Your server, your data, your bill.

package/apps/web/content/docs/_meta.json

@@ -0,0 +1,14 @@
+{
+  "title": "Documentation",
+  "root": true,
+  "pages": [
+    "index",
+    "quickstart",
+    "---Getting Started---",
+    "installation",
+    "first-deployment",
+    "---Reference---",
+    "cli",
+    "api"
+  ]
+}

package/apps/web/content/docs/api.mdx

@@ -0,0 +1,98 @@
+---
+title: API Reference
+description: Openship REST API for programmatic access to deployments, projects, and infrastructure.
+---
+
+# API Reference
+
+The Openship API lets you manage everything programmatically. All endpoints require an API key.
+
+## Authentication
+
+```bash
+curl -H "Authorization: Bearer os_key_..." https://api.openship.io/v1/projects
+```
+
+Generate an API key from **Dashboard → Settings → API Keys**.
+
+## Projects
+
+### List projects
+
+```
+GET /v1/projects
+```
+
+```json
+{
+  "projects": [
+    {
+      "id": "proj_abc123",
+      "name": "my-app",
+      "framework": "nextjs",
+      "status": "active",
+      "url": "https://my-app.openship.io"
+    }
+  ]
+}
+```
+
+### Create project
+
+```
+POST /v1/projects
+```
+
+```json
+{
+  "name": "my-app",
+  "repo": "https://github.com/you/my-app",
+  "branch": "main"
+}
+```
+
+## Deployments
+
+### Trigger deployment
+
+```
+POST /v1/projects/:id/deployments
+```
+
+### Get deployment status
+
+```
+GET /v1/deployments/:id
+```
+
+```json
+{
+  "id": "dpl_xyz789",
+  "status": "live",
+  "url": "https://my-app.openship.io",
+  "created_at": "2026-03-08T12:00:00Z",
+  "build_time_ms": 14200
+}
+```
+
+## Domains
+
+### Add domain
+
+```
+POST /v1/projects/:id/domains
+```
+
+```json
+{
+  "domain": "example.com"
+}
+```
+
+## Rate limits
+
+| Plan | Requests/min |
+|------|-------------|
+| Free | 60 |
+| Pro | 300 |
+| Self-hosted | Unlimited |

package/apps/web/content/docs/cli.mdx

@@ -0,0 +1,80 @@
+---
+title: CLI Reference
+description: Openship CLI commands for managing deployments from the terminal.
+---
+
+# CLI Reference
+
+The Openship CLI lets you manage projects, deployments, domains, and more from your terminal.
+
+## Installation
+
+```bash
+curl -fsSL https://get.openship.io/cli | sh
+```
+
+Or via npm:
+
+```bash
+npx openship
+```
+
+## Commands
+
+### `openship init`
+
+Initialize a project in the current directory.
+
+```bash
+openship init
+```
+
+Detects your framework, generates `openship.json`, and links to a project.
+
+### `openship deploy`
+
+Deploy the current project.
+
+```bash
+openship deploy              # Deploy from current directory
+openship deploy --prod       # Deploy to production
+openship deploy --preview    # Create a preview deployment
+```
+
+### `openship projects`
+
+```bash
+openship projects list                    # List all projects
+openship projects create --name my-app    # Create a new project
+openship projects delete my-app           # Delete a project
+```
+
+### `openship domains`
+
+```bash
+openship domains list --project my-app
+openship domains add example.com --project my-app
+openship domains remove example.com --project my-app
+```
+
+### `openship env`
+
+```bash
+openship env list --project my-app
+openship env set KEY=value --project my-app
+openship env remove KEY --project my-app
+```
+
+### `openship logs`
+
+```bash
+openship logs --project my-app           # Stream build + runtime logs
+openship logs --project my-app --build   # Build logs only
+```
+
+### `openship rollback`
+
+```bash
+openship rollback --project my-app                    # Rollback to previous
+openship rollback --project my-app --deployment abc123 # Rollback to specific
+```

package/apps/web/content/docs/first-deployment.mdx

@@ -0,0 +1,56 @@
+---
+title: First Deployment
+description: Deploy an app with custom domains, environment variables, and Git integration.
+---
+
+# First Deployment
+
+This guide walks through deploying a real project with all the essentials configured.
+
+## Deploy from Git
+
+Connect a GitHub, GitLab, or Bitbucket repository:
+
+```bash
+openship projects create --repo https://github.com/you/your-app
+```
+
+Openship automatically:
+- Detects the framework and build command
+- Generates an optimized Dockerfile (if needed)
+- Builds and deploys on every push to `main`
+
+## Custom domains
+
+```bash
+openship domains add yourapp.com --project your-app
+```
+
+SSL certificates are provisioned automatically via Let's Encrypt. Wildcard certificates are supported.
+
+## Environment variables
+
+```bash
+openship env set DATABASE_URL="postgres://..." --project your-app
+openship env set REDIS_URL="redis://..." --project your-app
+```
+
+Variables are encrypted at rest and injected at build time and runtime.
+
+## Preview deployments
+
+Every pull request gets a unique preview URL:
+
+```
+https://pr-42--your-app.preview.openship.io
+```
+
+Preview deployments are destroyed automatically when the PR is merged or closed.
+
+## Rollbacks
+
+```bash
+openship rollback --project your-app
+```
+
+Instant rollback to any previous deployment. Zero downtime.

package/apps/web/content/docs/index.mdx

@@ -0,0 +1,27 @@
+---
+title: Introduction
+description: Welcome to Openship — the open-source, self-hostable deployment platform.
+---
+
+# Welcome to Openship
+
+Openship is an open-source deployment platform that lets you deploy apps, databases, and full-stack infrastructure on your own servers.
+
+## Why Openship?
+
+- **Self-hosted** — Run on your own servers. Your data stays yours.
+- **AI-assisted** — Intelligent build detection, config generation, and diagnostics.
+- **Zero lock-in** — Export everything, migrate anytime. No proprietary formats.
+- **Open source** — MIT licensed. Inspect, modify, contribute.
+
+## How it works
+
+1. **Connect** — Point Openship at your Git repo or push a Docker image.
+2. **Build** — AI detects your framework and configures the build automatically.
+3. **Deploy** — Your app goes live with SSL, domains, and monitoring out of the box.
+
+## Next steps
+
+- [Quickstart](/docs/quickstart) — Deploy your first app in under 2 minutes.
+- [Installation](/docs/installation) — Set up Openship on your own server.
+- [CLI Reference](/docs/cli) — Manage deployments from the terminal.

package/apps/web/content/docs/installation.mdx

@@ -0,0 +1,65 @@
+---
+title: Installation
+description: Install Openship on your own server or use the managed cloud.
+---
+
+# Installation
+
+Openship runs on any Linux server. You can self-host it or use Openship Cloud.
+
+## Self-hosted
+
+### System requirements
+
+| Component | Minimum | Recommended |
+|-----------|---------|-------------|
+| CPU | 2 cores | 4+ cores |
+| RAM | 2 GB | 4+ GB |
+| Disk | 20 GB | 50+ GB SSD |
+| OS | Ubuntu 22.04+ | Ubuntu 24.04 |
+
+### One-line install
+
+```bash
+curl -fsSL https://get.openship.io | sh
+```
+
+### Docker Compose
+
+```yaml
+version: "3.8"
+services:
+  openship:
+    image: ghcr.io/openshiporg/openship:latest
+    ports:
+      - "3000:3000"
+      - "443:443"
+      - "80:80"
+    volumes:
+      - openship-data:/data
+    restart: unless-stopped
+
+volumes:
+  openship-data:
+```
+
+```bash
+docker compose up -d
+```
+
+### Verify
+
+```bash
+openship status
+```
+
+You should see `Openship daemon running` with the dashboard URL.
+
+## Openship Cloud
+
+Don't want to manage a server? [Sign up for Openship Cloud](https://app.openship.io) — same platform, fully managed.
+
+## Next steps
+
+- [Deploy your first app](/docs/first-deployment)
+- [CLI reference](/docs/cli)

package/apps/web/content/docs/quickstart.mdx

@@ -0,0 +1,45 @@
+---
+title: Quickstart
+description: Deploy your first app with Openship in under 2 minutes.
+---
+
+# Quickstart
+
+Get from zero to a live deployment in three steps.
+
+## Prerequisites
+
+- A server running Linux (Ubuntu 22.04+ recommended)
+- Docker installed
+- A domain name (optional, but recommended)
+
+## 1. Install Openship
+
+```bash
+curl -fsSL https://get.openship.io | sh
+```
+
+This installs the Openship CLI and daemon on your server.
+
+## 2. Initialize a project
+
+```bash
+cd your-project
+openship init
+```
+
+Openship detects your framework (Next.js, Node, Python, Go, etc.) and generates a deploy config.
+
+## 3. Deploy
+
+```bash
+openship deploy
+```
+
+That's it. Your app is live with automatic SSL and a preview URL.
+
+## What's next?
+
+- [Add a custom domain](/docs/first-deployment#custom-domains)
+- [Set up environment variables](/docs/first-deployment#environment-variables)
+- [Configure automatic deploys from Git](/docs/first-deployment#git-integration)

package/apps/web/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/dev/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.