openship 0.1.0 → 0.1.1

package/apps/api/src/modules/deployments/deployment-lifecycle.ts

@@ -0,0 +1,138 @@
+/**
+ * Deployment lifecycle hooks — shared onSuccess / onFailure for the
+ * entire build→deploy process.
+ *
+ * The orchestrator (build.service.ts) creates a lifecycle context once
+ * at the start of a deployment, then calls onSuccess or onFailure at
+ * the end. These hooks handle everything:
+ *
+ *   onFailure  →  destroy resources → mark DB failed → finish session → SSE → notify
+ *   onSuccess  →  persist container → mark DB ready → finish session → SSE → notify
+ *
+ * This keeps the orchestrator focused on sequencing (build → deploy)
+ * while all side-effects on completion live here.
+ */
+
+import { repos, type Project, type Deployment } from "@repo/db";
+import type { LogEntry } from "@repo/adapters";
+import type { RuntimeAdapter } from "@repo/adapters";
+import { SYSTEM } from "@repo/core";
+import { notifyDeploySuccess, notifyBuildFailed } from "../../lib/notifications";
+import * as sessionManager from "./session-manager";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface LifecycleContext {
+  runtime: RuntimeAdapter;
+  project: Project;
+  dep: Deployment;
+  buildSessionId: string;
+  /** Returns collapsed logs for DB persistence. */
+  persistLogs: () => LogEntry[];
+  /** Provisioned resources — set by the orchestrator as phases progress. */
+  provisioned: { imageRef?: string };
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function truncateError(msg: string): string {
+  const max = SYSTEM.DEPLOYMENTS.MAX_ERROR_MESSAGE_LENGTH;
+  return msg.length > max ? msg.slice(0, max) + "…" : msg;
+}
+
+// ─── Hooks ───────────────────────────────────────────────────────────────────
+
+export async function onFailure(
+  ctx: LifecycleContext,
+  error?: string,
+  durationMs?: number,
+): Promise<void> {
+  const { runtime, project, dep, buildSessionId, persistLogs, provisioned } = ctx;
+
+  // 1. Force destroy provisioned resources — always delete the workspace/container
+  //    on failure so the user doesn't have to manually clean up.
+  if (provisioned.imageRef) {
+    try {
+      await runtime.destroy(provisioned.imageRef);
+    } catch (destroyErr) {
+      console.error(
+        `[DEPLOY] Failed to destroy ${provisioned.imageRef} on failure:`,
+        destroyErr,
+      );
+      // Retry once after a short delay
+      await new Promise((r) => setTimeout(r, 2000));
+      await runtime.destroy(provisioned.imageRef).catch((retryErr) => {
+        console.error(
+          `[DEPLOY] Retry destroy also failed for ${provisioned.imageRef}:`,
+          retryErr,
+        );
+      });
+    }
+  }
+
+  // 2. Persist failure state
+  const errorMessage = error ? truncateError(error) : undefined;
+  const collapsed = persistLogs();
+  await repos.deployment.updateStatus(dep.id, "failed", { errorMessage });
+  await repos.deployment.finishBuildSession(buildSessionId, "failed", durationMs ?? 0, collapsed);
+  sessionManager.updateStatus(dep.id, "failed");
+
+  // 3. Notify
+  const user = await repos.user.findById(dep.userId);
+  if (user?.email) {
+    const lastLogs = collapsed.slice(-50).map((l) => l.message).join("\n");
+    void notifyBuildFailed(user.email, project, {
+      branch: dep.branch,
+      error: errorMessage ?? "Unknown error",
+      logs: lastLogs,
+    });
+  }
+}
+
+export async function onCancelled(
+  ctx: LifecycleContext,
+  durationMs?: number,
+): Promise<void> {
+  const { runtime, dep, buildSessionId, persistLogs, provisioned } = ctx;
+
+  // Force destroy provisioned resources
+  if (provisioned.imageRef) {
+    try {
+      await runtime.destroy(provisioned.imageRef);
+    } catch (destroyErr) {
+      console.error(
+        `[DEPLOY] Failed to destroy ${provisioned.imageRef} on cancel:`,
+        destroyErr,
+      );
+      await new Promise((r) => setTimeout(r, 2000));
+      await runtime.destroy(provisioned.imageRef).catch(() => {});
+    }
+  }
+
+  await repos.deployment.updateStatus(dep.id, "cancelled");
+  await repos.deployment.finishBuildSession(buildSessionId, "cancelled", durationMs ?? 0, persistLogs());
+  sessionManager.updateStatus(dep.id, "cancelled");
+}
+
+export async function onSuccess(
+  ctx: LifecycleContext,
+  result: { containerId: string; url?: string; durationMs: number },
+): Promise<void> {
+  const { project, dep, buildSessionId, persistLogs } = ctx;
+
+  await repos.deployment.setContainerId(dep.id, result.containerId, result.url);
+  await repos.deployment.updateStatus(dep.id, "ready");
+  await repos.project.setActiveDeployment(project.id, dep.id);
+  await repos.deployment.finishBuildSession(buildSessionId, "ready", result.durationMs, persistLogs());
+  sessionManager.updateStatus(dep.id, "ready");
+
+  const user = await repos.user.findById(dep.userId);
+  if (user?.email) {
+    void notifyDeploySuccess(user.email, project, {
+      branch: dep.branch,
+      commitSha: dep.commitSha,
+      url: result.url,
+      durationMs: result.durationMs,
+    });
+  }
+}

package/apps/api/src/modules/deployments/deployment.controller.ts

@@ -1,35 +1,343 @@
+/**
+ * Deployment controller — Hono request handlers.
+ */
+
 import type { Context } from "hono";
+import { streamSSE } from "hono/streaming";
+import { getUserId, param } from "../../lib/controller-helpers";
+import * as deploymentService from "./deployment.service";
+import * as buildService from "./build.service";
+import * as sslService from "./ssl.service";
+import * as prepareService from "./prepare.service";
+import { env } from "../../config";
+
+// ─── Handlers ────────────────────────────────────────────────────────────────
 
 export async function list(c: Context) {
-  // TODO: List deployments (optionally filtered by projectId)
-  return c.json({ data: [] });
+  const userId = getUserId(c);
+  const projectId = c.req.query("projectId");
+  const environment = c.req.query("environment");
+  const page = Number(c.req.query("page") ?? 1);
+  const perPage = Number(c.req.query("perPage") ?? 50);
+
+  const result = await deploymentService.listDeployments(userId, {
+    projectId: projectId ?? undefined,
+    environment: environment ?? undefined,
+    page,
+    perPage,
+  });
+
+  return c.json({
+    success: true,
+    data: result.rows,
+    total: result.total,
+    page: result.page,
+    perPage: result.perPage,
+  });
 }
 
 export async function create(c: Context) {
-  // TODO: Trigger new deployment via adapter
-  return c.json({ message: "deployment queued" }, 202);
+  const userId = getUserId(c);
+  const body = await c.req.json<{ projectId: string; branch?: string; commitSha?: string; environment?: string }>();
+  const result = await buildService.triggerDeployment(userId, body);
+  return c.json({ data: result }, 202);
 }
 
 export async function getById(c: Context) {
-  const id = c.req.param("id");
-  // TODO: Get deployment details + status
-  return c.json({ data: { id } });
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const dep = await deploymentService.getDeployment(id, userId);
+  return c.json({ data: dep });
 }
 
 export async function logs(c: Context) {
-  const id = c.req.param("id");
-  // TODO: Stream or return deployment logs
-  return c.json({ data: { id, logs: [] } });
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const tail = c.req.query("tail") ? Number(c.req.query("tail")) : undefined;
+  const logEntries = await deploymentService.getDeploymentLogs(id, userId, tail);
+  return c.json({ data: logEntries });
+}
+
+/**
+ * Shared SSE streaming helper — subscribes to a build session and
+ * keeps the connection open until the client disconnects or session ends.
+ */
+function streamBuildSession(c: Context, deploymentId: string, initialEvent?: { event: string; data: string }) {
+  return streamSSE(c, async (sseStream) => {
+    let closed = false;
+
+    if (initialEvent) {
+      await sseStream.writeSSE(initialEvent);
+    }
+
+    const writer = (event: string, data: string): boolean => {
+      if (closed) return false;
+      try {
+        void sseStream.writeSSE({ event, data });
+        return true;
+      } catch {
+        return false;
+      }
+    };
+
+    const { success, unsubscribe } = buildService.subscribeToBuildSession(deploymentId, writer);
+
+    if (!success) {
+      await sseStream.writeSSE({ event: "error", data: JSON.stringify({ error: "Session not found" }) });
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (closed) {
+          clearInterval(checkInterval);
+          resolve();
+        }
+      }, 1000);
+
+      sseStream.onAbort(() => {
+        closed = true;
+        unsubscribe();
+        clearInterval(checkInterval);
+        resolve();
+      });
+    });
+  });
+}
+
+/**
+ * SSE endpoint for streaming build logs in real-time.
+ * GET /deployments/:id/stream
+ */
+export async function stream(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  // Verify the requesting user owns this deployment before streaming
+  await deploymentService.getDeployment(id, userId);
+  return streamBuildSession(c, id);
 }
 
 export async function rollback(c: Context) {
-  const id = c.req.param("id");
-  // TODO: Rollback to this deployment
-  return c.json({ message: "rollback initiated" });
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const dep = await deploymentService.rollbackDeployment(id, userId);
+  return c.json({ data: dep });
 }
 
 export async function cancel(c: Context) {
-  const id = c.req.param("id");
-  // TODO: Cancel in-progress deployment
-  return c.json({ message: "deployment cancelled" });
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  try {
+    const result = await buildService.cancelBuildSession(id, userId);
+    return c.json(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to cancel deployment";
+    return c.json({ success: false, error: message }, 400);
+  }
+}
+
+export async function remove(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  try {
+    await deploymentService.deleteDeployment(id, userId);
+    return c.json({ success: true, message: "Deployment deleted" });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to delete deployment";
+    return c.json({ success: false, error: message }, 400);
+  }
+}
+
+export async function restart(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const dep = await deploymentService.restartDeployment(id, userId);
+  return c.json({ data: dep });
+}
+
+export async function containerInfo(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const info = await deploymentService.getContainerInfo(id, userId);
+  return c.json({ data: info });
+}
+
+export async function containerUsage(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+  const usage = await deploymentService.getContainerUsage(id, userId);
+  return c.json({ data: usage });
+}
+
+// ─── Prepare (resolve project info) ────────────────────────────────────────────
+
+/**
+ * POST /deployments/prepare — resolve project info from GitHub or local path.
+ *
+ * Body (GitHub): { source: "github", owner, repo }
+ * Body (local):  { source: "local", path: "/abs/path" }
+ * Legacy:        { owner, repo }  (treated as GitHub)
+ */
+export async function prepare(c: Context) {
+  const userId = getUserId(c);
+  const body = await c.req.json<{
+    source?: "github" | "local";
+    owner?: string;
+    repo?: string;
+    path?: string;
+  }>();
+
+  // Determine source — legacy callers send { owner, repo } without source
+  const source = body.source ?? (body.owner && body.repo ? "github" : undefined);
+
+  try {
+    let input: prepareService.Source;
+
+    if (source === "github") {
+      if (!body.owner || !body.repo) {
+        return c.json({ error: "owner and repo are required" }, 400);
+      }
+      input = { source: "github", owner: body.owner, repo: body.repo, userId };
+    } else if (source === "local") {
+      if (env.CLOUD_MODE) {
+        return c.json({ error: "Local projects are not available in cloud mode" }, 403);
+      }
+      if (!body.path) {
+        return c.json({ error: "path is required" }, 400);
+      }
+      input = { source: "local", path: body.path };
+    } else {
+      return c.json({ error: "source must be 'github' or 'local'" }, 400);
+    }
+
+    const info = await prepareService.resolveProjectInfo(input);
+    return c.json(info);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to initialize deploy";
+    return c.json({ error: message }, 400);
+  }
+}
+
+// ─── Build access / status / cancel / redeploy ───────────────────────────────
+
+/**
+ * POST /deployments/build/access — create deployment + build session for existing project.
+ * Requires { projectId }. Returns { success, deployment_id, project_id }.
+ */
+export async function buildAccess(c: Context) {
+  const userId = getUserId(c);
+  const body = await c.req.json<buildService.BuildAccessInput>();
+
+  if (!body.projectId) {
+    return c.json({ success: false, message: "projectId is required" }, 400);
+  }
+
+  try {
+    const result = await buildService.requestBuildAccess(userId, body);
+    return c.json(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to start deployment";
+    return c.json({ success: false, message }, 400);
+  }
+}
+
+/**
+ * GET /deployments/:id/build — get build session status and config.
+ */
+export async function buildStatus(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+
+  try {
+    const result = await buildService.getBuildSessionStatus(id, userId);
+    return c.json(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Build session not found";
+    return c.json({ success: false, error: message }, 404);
+  }
+}
+
+/**
+ * POST /deployments/:id/redeploy — redeploy from an existing deployment.
+ */
+export async function buildRedeploy(c: Context) {
+  const userId = getUserId(c);
+  const id = param(c, "id");
+
+  try {
+    const result = await buildService.redeployBuildSession(id, userId);
+    return c.json(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to redeploy";
+    return c.json({ success: false, error: message }, 400);
+  }
+}
+
+/**
+ * POST /deployments/:id/build — start a build for a queued deployment.
+ * Kicks off the build pipeline, then streams build logs via SSE.
+ * Client can reconnect via GET /:id/stream.
+ */
+export async function buildStart(c: Context) {
+  const userId = getUserId(c);
+  const deploymentId = param(c, "id");
+
+  let result;
+  try {
+    result = await buildService.startBuild(deploymentId, userId);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to start build";
+    return c.json({ success: false, error: message }, 400);
+  }
+
+  return streamBuildSession(c, deploymentId, {
+    event: "started",
+    data: JSON.stringify({
+      type: "started",
+      deployment_id: result.deployment_id,
+      project_id: result.project_id,
+    }),
+  });
+}
+
+// ─── SSL ─────────────────────────────────────────────────────────────────────
+
+/**
+ * POST /deployments/ssl/status — check SSL status for a domain.
+ */
+export async function sslStatus(c: Context) {
+  const userId = getUserId(c);
+  const body = await c.req.json<{ domain: string }>();
+
+  if (!body.domain) {
+    return c.json({ success: false, error: "domain is required" }, 400);
+  }
+
+  try {
+    const result = await sslService.getStatus(body.domain, userId);
+    return c.json({ success: true, ...result });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to check SSL status";
+    return c.json({ success: false, error: message }, 400);
+  }
+}
+
+/**
+ * POST /deployments/ssl/renew — renew SSL certificate for a domain.
+ */
+export async function sslRenew(c: Context) {
+  const userId = getUserId(c);
+  const body = await c.req.json<{ domain: string; includeWww?: boolean }>();
+
+  if (!body.domain) {
+    return c.json({ success: false, error: "domain is required" }, 400);
+  }
+
+  try {
+    const result = await sslService.renew(body.domain, userId, body.includeWww);
+    return c.json(result);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to renew SSL";
+    return c.json({ success: false, error: message }, 400);
+  }
 }

package/apps/api/src/modules/deployments/deployment.routes.ts

@@ -1,11 +1,37 @@
+/**
+ * Deployment routes — mounted at /api/deployments in app.ts.
+ */
+
 import { Hono } from "hono";
-import * as deploymentController from "./deployment.controller";
+import { authMiddleware } from "../../middleware";
+import * as ctrl from "./deployment.controller";
 
 export const deploymentRoutes = new Hono();
+deploymentRoutes.use("*", authMiddleware);
+
+/* ── CRUD + operations ─────────────────────────────────────────────── */
+deploymentRoutes.get("/", ctrl.list);
+deploymentRoutes.post("/", ctrl.create);
+deploymentRoutes.post("/prepare", ctrl.prepare);
+
+/* ── Build access (creates a new deployment — no ID yet) ───────────── */
+deploymentRoutes.post("/build/access", ctrl.buildAccess);
+
+/* ── SSL ───────────────────────────────────────────────────────────── */
+deploymentRoutes.post("/ssl/status", ctrl.sslStatus);
+deploymentRoutes.post("/ssl/renew", ctrl.sslRenew);
+
+/* ── Deployment by ID ──────────────────────────────────────────────── */
+deploymentRoutes.get("/:id", ctrl.getById);
+deploymentRoutes.get("/:id/logs", ctrl.logs);
+deploymentRoutes.get("/:id/stream", ctrl.stream);
+deploymentRoutes.get("/:id/build", ctrl.buildStatus);
+deploymentRoutes.post("/:id/build", ctrl.buildStart);
+deploymentRoutes.post("/:id/redeploy", ctrl.buildRedeploy);
+deploymentRoutes.post("/:id/rollback", ctrl.rollback);
+deploymentRoutes.post("/:id/cancel", ctrl.cancel);
+deploymentRoutes.delete("/:id", ctrl.remove);
+deploymentRoutes.post("/:id/restart", ctrl.restart);
+deploymentRoutes.get("/:id/info", ctrl.containerInfo);
+deploymentRoutes.get("/:id/usage", ctrl.containerUsage);
 
-deploymentRoutes.get("/", deploymentController.list);
-deploymentRoutes.post("/", deploymentController.create);
-deploymentRoutes.get("/:id", deploymentController.getById);
-deploymentRoutes.get("/:id/logs", deploymentController.logs);
-deploymentRoutes.post("/:id/rollback", deploymentController.rollback);
-deploymentRoutes.post("/:id/cancel", deploymentController.cancel);

package/apps/api/src/modules/deployments/deployment.schema.ts

@@ -1,7 +1,39 @@
-import { z } from "zod";
+/**
+ * Deployment validation schemas — TypeBox for Hono route validation.
+ */
 
-export const createDeploymentSchema = z.object({
-  projectId: z.string().uuid(),
-  branch: z.string().default("main"),
-  environment: z.enum(["production", "preview"]).default("production"),
+import { Type, type Static } from "@sinclair/typebox";
+
+// ─── Route params ────────────────────────────────────────────────────────────
+
+export const DeploymentIdParam = Type.Object({
+  id: Type.String({ minLength: 1 }),
+});
+
+// ─── Query params ────────────────────────────────────────────────────────────
+
+export const ListDeploymentsQuery = Type.Object({
+  projectId: Type.Optional(Type.String()),
+  environment: Type.Optional(Type.Union([
+    Type.Literal("production"), Type.Literal("preview"),
+  ])),
+  page: Type.Optional(Type.Number({ minimum: 1, default: 1 })),
+  perPage: Type.Optional(Type.Number({ minimum: 1, maximum: 100, default: 20 })),
 });
+
+// ─── Request bodies ──────────────────────────────────────────────────────────
+
+export const TriggerDeployBody = Type.Object({
+  projectId: Type.String({ minLength: 1 }),
+  branch: Type.Optional(Type.String({ default: "main" })),
+  commitSha: Type.Optional(Type.String()),
+  environment: Type.Optional(Type.Union([
+    Type.Literal("production"), Type.Literal("preview"),
+  ])),
+});
+
+// ─── Inferred types ──────────────────────────────────────────────────────────
+
+export type TDeploymentIdParam = Static<typeof DeploymentIdParam>;
+export type TListDeploymentsQuery = Static<typeof ListDeploymentsQuery>;
+export type TTriggerDeployBody = Static<typeof TriggerDeployBody>;