openship 0.1.0 → 0.1.1

package/apps/api/src/modules/deployments/prepare.service.ts

@@ -0,0 +1,252 @@
+/**
+ * Prepare service — resolves project info from a source (GitHub or local path).
+ *
+ * Pure introspection: reads files, detects stack, returns a unified shape.
+ * No database writes, no deployment logic.
+ */
+
+import * as githubService from "../github/github.service";
+import { detectStack, MANIFEST_FILES, type RepoFile, type StackResult } from "../../lib/stack-detector";
+import { parseComposeFile, type ComposeService } from "../../lib/compose-parser";
+import type { ProjectType } from "@repo/core";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { env } from "../../config";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type Source =
+  | { source: "github"; owner: string; repo: string; userId: string }
+  | { source: "local"; path: string };
+
+export interface ProjectInfo {
+  repository: {
+    name: string;
+    full_name: string;
+    owner: { login: string };
+    private: boolean;
+    default_branch: string;
+    clone_url?: string;
+    html_url?: string;
+    branches?: { name: string }[];
+  };
+  stack: StackResult["stack"];
+  projectType: ProjectType;
+  category: string;
+  packageManager: string;
+  buildCommand: string;
+  installCommand: string;
+  startCommand: string;
+  buildImage: string;
+  outputDirectory: string;
+  productionPaths: string[];
+  port: number;
+  services?: ComposeService[];
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Resolve project info from either a GitHub repo or a local filesystem path.
+ * Both paths converge on detectStack and return the same ProjectInfo shape.
+ */
+export async function resolveProjectInfo(input: Source): Promise<ProjectInfo> {
+  if (input.source === "github") {
+    return resolveFromGitHub(input.userId, input.owner, input.repo);
+  }
+
+  // Local filesystem access — blocked in cloud mode
+  if (env.CLOUD_MODE) {
+    throw new Error("Local project resolution is not available in cloud mode");
+  }
+
+  return resolveFromLocal(input.path);
+}
+
+// ─── GitHub ──────────────────────────────────────────────────────────────────
+
+async function resolveFromGitHub(userId: string, owner: string, repo: string): Promise<ProjectInfo> {
+  const repository = await githubService.getRepository(userId, owner, repo, {
+    withBranches: true,
+  });
+
+  let files: RepoFile[] = [];
+  let packageJson: Record<string, unknown> | undefined;
+
+  try {
+    const contents = await githubService.listFiles(userId, owner, repo, {
+      branch: repository.default_branch,
+    });
+    if (Array.isArray(contents)) {
+      files = contents.map((f: any) => ({
+        name: f.name,
+        type: f.type === "dir" ? "dir" : "file",
+      }));
+    }
+  } catch {
+    // Repo might be empty
+  }
+
+  try {
+    const pkgFile = await githubService.getFileContent(userId, owner, repo, "package.json", {
+      branch: repository.default_branch,
+      json: true,
+    });
+    if (pkgFile?.content) {
+      packageJson = typeof pkgFile.content === "string"
+        ? JSON.parse(pkgFile.content)
+        : pkgFile.content;
+    }
+  } catch {
+    // No package.json
+  }
+
+  // Try reading compose file
+  let composeContent: string | undefined;
+  const composeNames = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+  for (const name of composeNames) {
+    if (files.some((f) => f.name.toLowerCase() === name)) {
+      try {
+        const composeFile = await githubService.getFileContent(userId, owner, repo, name, {
+          branch: repository.default_branch,
+        });
+        if (composeFile?.content) {
+          composeContent = composeFile.content;
+          break;
+        }
+      } catch {
+        // Not found, try next
+      }
+    }
+  }
+
+  // Read manifest files for deep stack detection
+  const manifests: Record<string, string> = {};
+  const manifestReads = MANIFEST_FILES
+    .filter((name) => files.some((f) => f.name.toLowerCase() === name.toLowerCase()))
+    .map(async (name) => {
+      try {
+        const file = await githubService.getFileContent(userId, owner, repo, name, {
+          branch: repository.default_branch,
+        });
+        if (file?.content) manifests[name] = file.content;
+      } catch { /* skip */ }
+    });
+  await Promise.all(manifestReads);
+
+  return toProjectInfo(repository, files, packageJson, composeContent, manifests);
+}
+
+// ─── Local filesystem ────────────────────────────────────────────────────────
+
+async function resolveFromLocal(dirPath: string): Promise<ProjectInfo> {
+  const st = await stat(dirPath);
+  if (!st.isDirectory()) {
+    throw new Error("Path is not a directory");
+  }
+
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  const files: RepoFile[] = entries.map((e) => ({
+    name: e.name,
+    type: e.isDirectory() ? "dir" : "file",
+  }));
+
+  let packageJson: Record<string, unknown> | undefined;
+  try {
+    const raw = await readFile(`${dirPath}/package.json`, "utf-8");
+    packageJson = JSON.parse(raw);
+  } catch {
+    // No package.json or invalid — that's fine
+  }
+
+  // Try reading compose file
+  let composeContent: string | undefined;
+  const composeNames = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+  for (const name of composeNames) {
+    try {
+      composeContent = await readFile(`${dirPath}/${name}`, "utf-8");
+      break;
+    } catch {
+      // Try next
+    }
+  }
+
+  // Read manifest files for deep stack detection
+  const manifests: Record<string, string> = {};
+  await Promise.all(
+    MANIFEST_FILES.map(async (name) => {
+      try {
+        manifests[name] = await readFile(`${dirPath}/${name}`, "utf-8");
+      } catch { /* skip */ }
+    }),
+  );
+
+  const dirName = (packageJson?.name as string) ?? basename(dirPath);
+
+  const repoShape = {
+    name: dirName,
+    full_name: dirPath,
+    owner: "local",
+    private: true,
+    default_branch: "main",
+  } as const;
+
+  return toProjectInfo(repoShape, files, packageJson, composeContent, manifests);
+}
+
+// ─── Shared mapper ───────────────────────────────────────────────────────────
+
+function toProjectInfo(
+  repo: {
+    name: string;
+    full_name: string;
+    owner: string;
+    private: boolean;
+    default_branch: string;
+    clone_url?: string;
+    html_url?: string;
+    branches?: { name: string }[];
+  },
+  files: RepoFile[],
+  packageJson?: Record<string, unknown>,
+  composeContent?: string,
+  fileContents?: Record<string, string>,
+): ProjectInfo {
+  const stack = detectStack(files, packageJson, fileContents);
+
+  // Parse compose file if detected as a services project
+  let services: ComposeService[] | undefined;
+  if (composeContent && stack.projectType === "services") {
+    try {
+      const parsed = parseComposeFile(composeContent);
+      services = parsed.services;
+    } catch {
+      // Invalid YAML — continue without services
+    }
+  }
+
+  return {
+    repository: {
+      name: repo.name,
+      full_name: repo.full_name,
+      owner: { login: repo.owner },
+      private: repo.private,
+      default_branch: repo.default_branch,
+      clone_url: repo.clone_url,
+      html_url: repo.html_url,
+      branches: repo.branches,
+    },
+    stack: stack.stack,
+    projectType: stack.projectType,
+    category: stack.category,
+    packageManager: stack.packageManager,
+    buildCommand: stack.buildCommand,
+    installCommand: stack.installCommand,
+    startCommand: stack.startCommand,
+    buildImage: stack.buildImage,
+    outputDirectory: stack.outputDirectory,
+    productionPaths: stack.productionPaths,
+    port: stack.port,
+    ...(services && { services }),
+  };
+}

package/apps/api/src/modules/deployments/session-manager.ts

@@ -0,0 +1,283 @@
+/**
+ * Build session manager — manages active build SSE streams.
+ *
+ * Ported from old sessionManager.js into a typed, TtlCache-backed implementation.
+ * Uses Hono's SSE streaming instead of raw Express res.write().
+ *
+ * Responsibilities:
+ *   - Track active build sessions with log buffers
+ *   - Broadcast log entries to SSE subscribers
+ *   - Auto-cleanup stale sessions
+ *   - SSE heartbeat keep-alive for proxy compatibility
+ */
+
+import { SYSTEM } from "@repo/core";
+import { TtlCache } from "../../lib/cache";
+import type { LogEntry } from "@repo/adapters";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface BuildSessionState {
+  deploymentId: string;
+  projectId: string;
+  status: "queued" | "building" | "deploying" | "ready" | "failed" | "cancelled";
+  logs: LogEntry[];
+  /** SSE writer callbacks for active subscribers */
+  subscribers: Set<SseWriter>;
+  startedAt: number;
+}
+
+export type SseWriter = (event: string, data: string) => boolean;
+
+// ─── Step-to-progress mapping ────────────────────────────────────────────────
+
+const STEP_INDEX: Record<string, number> = {
+  clone: 0,
+  install: 1,
+  build: 2,
+  deploy: 3,
+};
+
+const STEP_PROGRESS: Record<string, number> = {
+  clone: 5,
+  install: 25,
+  build: 50,
+  deploy: 75,
+};
+
+/** Convert a LogEntry into the JSON payload the frontend expects. */
+function formatLogPayload(entry: LogEntry, eventId: number): string {
+  // Use native base64 when available (cloud adapter), otherwise encode.
+  // Local/SSH logs are single lines without trailing newlines — append \n
+  // so the terminal renders each entry on its own line.
+  const base64Data = entry.rawData ?? Buffer.from(entry.message + "\n").toString("base64");
+  return JSON.stringify({
+    type: "log",
+    data: base64Data,
+    eventId,
+    step: entry.step,
+    stepStatus: entry.stepStatus,
+    level: entry.level,
+  });
+}
+
+// ─── Cache ───────────────────────────────────────────────────────────────────
+
+/** Active sessions cache — keyed by deployment ID (dep_xxx) */
+const sessions = new TtlCache<BuildSessionState>({
+  maxSize: SYSTEM.SSE.MAX_SESSIONS,
+  sweepIntervalMs: SYSTEM.SSE.SWEEP_INTERVAL_MS,
+});
+
+// ─── Heartbeat ───────────────────────────────────────────────────────────────
+
+/** Send keep-alive pings to all active subscribers to prevent connection drops */
+const heartbeatTimer = setInterval(() => {
+  for (const session of sessions.values()) {
+    const dead: SseWriter[] = [];
+    for (const writer of session.subscribers) {
+      const ok = writer("ping", "{}");
+      if (!ok) dead.push(writer);
+    }
+    for (const w of dead) session.subscribers.delete(w);
+  }
+}, SYSTEM.SSE.HEARTBEAT_INTERVAL_MS);
+
+// Don't keep the process alive just for heartbeats
+if (heartbeatTimer.unref) heartbeatTimer.unref();
+
+/** Create a new build session — keyed by deployment ID (dep_xxx). */
+export function createSession(
+  deploymentId: string,
+  projectId: string,
+): BuildSessionState {
+  const state: BuildSessionState = {
+    deploymentId,
+    projectId,
+    status: "queued",
+    logs: [],
+    subscribers: new Set(),
+    startedAt: Date.now(),
+  };
+  sessions.set(deploymentId, state, SYSTEM.SSE.SESSION_TTL_SECONDS);
+  return state;
+}
+
+/** Get an active session */
+export function getSession(sessionId: string): BuildSessionState | null {
+  return sessions.get(sessionId);
+}
+
+/** Append a log entry and broadcast to subscribers */
+export function appendLog(sessionId: string, entry: LogEntry): void {
+  const session = sessions.get(sessionId);
+  if (!session) return;
+
+  session.logs.push(entry);
+  if (session.logs.length > SYSTEM.SSE.MAX_LOGS_PER_SESSION) {
+    session.logs.splice(0, session.logs.length - SYSTEM.SSE.MAX_LOGS_PER_SESSION);
+  }
+
+  // Step-metadata entries (running/completed/failed) only drive the progress
+  // bar — they should NOT be written to the terminal as log lines.
+  const isStepMeta = !!entry.step && !!entry.stepStatus;
+
+  // Broadcast raw log to terminal (skip step-metadata-only entries)
+  if (!isStepMeta) {
+    const logPayload = formatLogPayload(entry, session.logs.length - 1);
+    const dead: SseWriter[] = [];
+    for (const writer of session.subscribers) {
+      const ok = writer("log", logPayload);
+      if (!ok) dead.push(writer);
+    }
+    for (const w of dead) session.subscribers.delete(w);
+  }
+
+  // Emit a progress event when a new step starts
+  if (entry.step && entry.stepStatus === "running" && entry.step in STEP_INDEX) {
+    const progressPayload = JSON.stringify({
+      type: "progress",
+      currentStep: STEP_INDEX[entry.step],
+      progress: STEP_PROGRESS[entry.step],
+    });
+    for (const writer of session.subscribers) {
+      writer("progress", progressPayload);
+    }
+  }
+}
+
+/** Update session status and broadcast typed events */
+export function updateStatus(
+  sessionId: string,
+  status: BuildSessionState["status"],
+): void {
+  const session = sessions.get(sessionId);
+  if (!session) return;
+
+  session.status = status;
+
+  // Broadcast typed events matching frontend expectations
+  if (status === "ready") {
+    const payload = JSON.stringify({ type: "complete", success: true });
+    for (const writer of session.subscribers) {
+      writer("complete", payload);
+    }
+  } else if (status === "failed") {
+    const lastError = [...session.logs].reverse().find((l) => l.level === "error");
+    const payload = JSON.stringify({
+      type: "complete",
+      success: false,
+      message: lastError?.message || "Build failed",
+    });
+    for (const writer of session.subscribers) {
+      writer("complete", payload);
+    }
+  } else if (status === "cancelled") {
+    const payload = JSON.stringify({ type: "cancelled", message: "Build cancelled" });
+    for (const writer of session.subscribers) {
+      writer("cancelled", payload);
+    }
+  }
+
+  // Terminal states: send end event and close all subscribers
+  if (status === "ready" || status === "failed" || status === "cancelled") {
+    const endPayload = JSON.stringify({ type: "end", status });
+    for (const writer of session.subscribers) {
+      writer("end", endPayload);
+    }
+    session.subscribers.clear();
+  }
+}
+
+/** Subscribe a new SSE writer to a session, returns unsubscribe fn */
+export function subscribe(
+  sessionId: string,
+  writer: SseWriter,
+): { success: boolean; unsubscribe: () => void } {
+  const session = sessions.get(sessionId);
+  if (!session) return { success: false, unsubscribe: () => {} };
+
+  // Enforce subscriber limit — evict oldest if full
+  if (session.subscribers.size >= SYSTEM.SSE.MAX_SUBSCRIBERS_PER_SESSION) {
+    const oldest = session.subscribers.values().next().value;
+    if (oldest) {
+      oldest("end", JSON.stringify({ message: "Evicted: subscriber limit reached" }));
+      session.subscribers.delete(oldest);
+    }
+  }
+
+  session.subscribers.add(writer);
+
+  // Replay existing logs in the format the frontend expects
+  // Skip step-metadata entries (same filter as appendLog) — they drive progress, not terminal
+  // Track the highest step seen so we can emit a final progress event after replay
+  let highestStep = -1;
+  let highestStepProgress = 0;
+
+  for (let i = 0; i < session.logs.length; i++) {
+    const entry = session.logs[i];
+    const isStepMeta = !!entry.step && !!entry.stepStatus;
+
+    // Only replay real output entries to the terminal
+    if (!isStepMeta) {
+      const ok = writer("log", formatLogPayload(entry, i));
+      if (!ok) {
+        session.subscribers.delete(writer);
+        return { success: false, unsubscribe: () => {} };
+      }
+    }
+
+    // Track step progress from replayed entries
+    if (entry.step && entry.step in STEP_INDEX) {
+      const idx = STEP_INDEX[entry.step];
+      if (idx > highestStep) {
+        highestStep = idx;
+        highestStepProgress = STEP_PROGRESS[entry.step];
+      }
+    }
+  }
+
+  // Emit a progress event so the frontend knows the current step after replay
+  if (highestStep >= 0) {
+    writer("progress", JSON.stringify({
+      type: "progress",
+      currentStep: highestStep,
+      progress: highestStepProgress,
+    }));
+  }
+
+  // If session already finished, send typed completion + end events
+  if (["ready", "failed", "cancelled"].includes(session.status)) {
+    if (session.status === "ready") {
+      writer("complete", JSON.stringify({ type: "complete", success: true }));
+    } else if (session.status === "failed") {
+      const lastError = [...session.logs].reverse().find((l) => l.level === "error");
+      writer("complete", JSON.stringify({
+        type: "complete",
+        success: false,
+        message: lastError?.message || "Build failed",
+      }));
+    } else if (session.status === "cancelled") {
+      writer("cancelled", JSON.stringify({ type: "cancelled", message: "Build cancelled" }));
+    }
+    writer("end", JSON.stringify({ type: "end", status: session.status }));
+    session.subscribers.delete(writer);
+  }
+
+  return {
+    success: true,
+    unsubscribe: () => session.subscribers.delete(writer),
+  };
+}
+
+/** Remove a session completely */
+export function removeSession(sessionId: string): void {
+  const session = sessions.get(sessionId);
+  if (session) {
+    for (const writer of session.subscribers) {
+      writer("end", JSON.stringify({ message: "Session ended" }));
+    }
+    session.subscribers.clear();
+  }
+  sessions.delete(sessionId);
+}

package/apps/api/src/modules/deployments/ssl.service.ts

@@ -0,0 +1,73 @@
+/**
+ * SSL service — certificate status checks and renewal via platform adapters.
+ */
+
+import { repos } from "@repo/db";
+import { NotFoundError } from "@repo/core";
+import { platform } from "../../lib/controller-helpers";
+
+/**
+ * Check SSL status for a domain.
+ * Returns the DB record + live cert info from the adapter.
+ */
+export async function getStatus(hostname: string, userId: string) {
+  const domainRecord = await repos.domain.findByHostname(hostname);
+  if (!domainRecord) throw new NotFoundError("Domain", hostname);
+
+  // Verify ownership through project
+  const project = await repos.project.findById(domainRecord.projectId);
+  if (!project || project.userId !== userId) {
+    throw new NotFoundError("Domain", hostname);
+  }
+
+  return {
+    domain: domainRecord.hostname,
+    sslStatus: domainRecord.sslStatus,
+    sslIssuer: domainRecord.sslIssuer,
+    sslExpiresAt: domainRecord.sslExpiresAt,
+    verified: domainRecord.verified,
+  };
+}
+
+/**
+ * Renew (or provision) an SSL certificate for a domain.
+ */
+export async function renew(hostname: string, userId: string, includeWww = false) {
+  const domainRecord = await repos.domain.findByHostname(hostname);
+  if (!domainRecord) throw new NotFoundError("Domain", hostname);
+
+  const project = await repos.project.findById(domainRecord.projectId);
+  if (!project || project.userId !== userId) {
+    throw new NotFoundError("Domain", hostname);
+  }
+
+  const { ssl } = platform();
+  const result = await ssl.renewCert(hostname);
+
+  await repos.domain.updateSsl(domainRecord.id, {
+    sslStatus: "active",
+    sslIssuer: result.issuer,
+    sslExpiresAt: new Date(result.expiresAt),
+  });
+
+  // Optionally renew www subdomain
+  if (includeWww) {
+    const wwwHostname = `www.${hostname}`;
+    const wwwRecord = await repos.domain.findByHostname(wwwHostname);
+    if (wwwRecord) {
+      const wwwResult = await ssl.renewCert(wwwHostname);
+      await repos.domain.updateSsl(wwwRecord.id, {
+        sslStatus: "active",
+        sslIssuer: wwwResult.issuer,
+        sslExpiresAt: new Date(wwwResult.expiresAt),
+      });
+    }
+  }
+
+  return {
+    success: true,
+    domain: hostname,
+    expiresAt: result.expiresAt,
+    issuer: result.issuer,
+  };
+}

package/apps/api/src/modules/domains/domain.controller.ts

@@ -1,21 +1,73 @@
+/**
+ * Domain controller — Hono request handlers.
+ */
+
 import type { Context } from "hono";
+import { getUserId, param } from "../../lib/controller-helpers";
+import * as domainService from "./domain.service";
+import type { TAddDomainBody } from "./domain.schema";
+
+// ─── Handlers ────────────────────────────────────────────────────────────────
 
 export async function list(c: Context) {
-  return c.json({ data: [] });
+  const userId = getUserId(c);
+  const projectId = c.req.query("projectId");
+  if (!projectId) {
+    return c.json({ error: "projectId query parameter required" }, 400);
+  }
+  const domains = await domainService.listDomains(projectId, userId);
+  return c.json({ data: domains });
 }
 
 export async function add(c: Context) {
-  // TODO: Add custom domain, generate DNS verification record
-  return c.json({ message: "domain added" }, 201);
+  const userId = getUserId(c);
+  const body = await c.req.json<TAddDomainBody>();
+  const result = await domainService.addDomain(userId, body);
+  return c.json({ data: result.domain, records: result.records }, 201);
 }
 
 export async function remove(c: Context) {
-  const id = c.req.param("id");
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  await domainService.removeDomain(id, userId);
   return c.json({ message: "domain removed" });
 }
 
 export async function verify(c: Context) {
-  const id = c.req.param("id");
-  // TODO: Check DNS records to verify ownership
-  return c.json({ message: "verification started" });
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const result = await domainService.verifyDomain(id, userId);
+  return c.json(result);
+}
+
+export async function records(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const result = await domainService.getDomainRecords(id, userId);
+  return c.json({ data: result });
+}
+
+/** POST /domains/preview — get DNS records for a hostname (no DB write) */
+export async function preview(c: Context) {
+  const body = await c.req.json<{ hostname: string }>();
+  if (!body.hostname?.trim()) {
+    return c.json({ error: "hostname is required" }, 400);
+  }
+  const result = await domainService.previewRecords(body.hostname.trim().toLowerCase());
+  return c.json({ data: result });
+}
+
+/** POST /domains/:id/renew — renew SSL for a single domain */
+export async function renewSsl(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const result = await domainService.renewDomainSsl(id, userId);
+  return c.json({ data: result });
+}
+
+/** POST /domains/renew-all — batch SSL renewal for the requesting user's domains */
+export async function renewAllSsl(c: Context) {
+  const userId = getUserId(c);
+  const result = await domainService.renewUserCerts(userId);
+  return c.json({ data: result });
 }