openship 0.1.1 → 0.1.7

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

@@ -1,252 +0,0 @@
-/**
- * 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

@@ -1,283 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-/**
- * 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,73 +0,0 @@
-/**
- * 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) {
-  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) {
-  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 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 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 });
-}