openship 0.1.0 → 0.1.1

package/apps/dashboard/src/lib/api/settings.ts

@@ -0,0 +1,21 @@
+import { api } from "./client";
+import { endpoints } from "./endpoints";
+
+export type BuildMode = "auto" | "server" | "local";
+
+export interface UserSettingsResponse {
+  buildMode: BuildMode;
+}
+
+export const settingsApi = {
+  /** Get the current user's platform settings */
+  get: () => api.get<UserSettingsResponse>(endpoints.settings.get),
+
+  /** Create or update all platform settings */
+  upsert: (data: { buildMode: BuildMode }) =>
+    api.put<UserSettingsResponse>(endpoints.settings.upsert, data),
+
+  /** Update only the build mode preference */
+  updateBuildMode: (buildMode: BuildMode) =>
+    api.patch<UserSettingsResponse>(endpoints.settings.buildMode, { buildMode }),
+};

package/apps/dashboard/src/lib/api/system.ts

@@ -0,0 +1,159 @@
+import { api } from "./client";
+import { endpoints } from "./endpoints";
+
+export interface BrowseEntry {
+  name: string;
+  path: string;
+  isProject: boolean;
+}
+
+export interface BrowseResult {
+  path: string;
+  directories: BrowseEntry[];
+}
+
+export interface InstanceSettings {
+  configured: boolean;
+  serverName?: string | null;
+  sshHost?: string | null;
+  sshPort?: number;
+  sshUser?: string;
+  sshAuthMethod?: "password" | "key" | null;
+  sshKeyPath?: string | null;
+  sshJumpHost?: string | null;
+  sshArgs?: string | null;
+  tunnelProvider?: "edge" | "cloudflare" | "ngrok" | null;
+  defaultBuildMode?: "auto" | "server" | "local";
+}
+
+/** True when running inside the Electron desktop shell */
+function isElectron(): boolean {
+  return !!(window as any).desktop?.isDesktop;
+}
+
+export interface ComponentStatus {
+  name: string;
+  label: string;
+  description: string;
+  installable: boolean;
+  installed: boolean;
+  version?: string;
+  running?: boolean;
+  healthy: boolean;
+  message: string;
+}
+
+export interface ServerCheckResult {
+  components: ComponentStatus[];
+  ready: boolean;
+  missing: string[];
+}
+
+export interface InstallResultResponse {
+  component: string;
+  success: boolean;
+  version?: string;
+  error?: string;
+  logs?: string[];
+}
+
+export interface SetupComponentProgress {
+  name: string;
+  label: string;
+  status: "pending" | "installing" | "installed" | "failed";
+  error?: string;
+}
+
+export interface SetupSessionInfo {
+  active: boolean;
+  sessionId?: string;
+  status?: "running" | "completed" | "failed";
+  components?: SetupComponentProgress[];
+  startedAt?: number;
+  finishedAt?: number;
+}
+
+export interface SetupLogEvent {
+  type: "log";
+  timestamp: string;
+  component: string;
+  message: string;
+  level: "info" | "warn" | "error";
+}
+
+export interface ServerStats {
+  cpu: number;
+  memTotal: number;
+  memUsed: number;
+  memAvail: number;
+  diskTotal: number;
+  diskUsed: number;
+  diskAvail: number;
+  uptime: string;
+  load1: string;
+  load5: string;
+  load15: string;
+}
+
+export interface SetupProgressEvent {
+  type: "progress";
+  component: string | null;
+  status: string;
+  error?: string;
+  components: SetupComponentProgress[];
+}
+
+export interface SetupCompleteEvent {
+  type: "complete";
+  status: "completed" | "failed";
+  components: SetupComponentProgress[];
+  durationMs: number;
+}
+
+export const systemApi = {
+  /** List child directories at a given path (backend browse) */
+  browse: (path?: string) =>
+    api.get<BrowseResult>(endpoints.system.browse, {
+      params: path ? { path } : undefined,
+    }),
+
+  /** Native folder picker (Electron) — returns absolute path or null */
+  pickFolder: async (): Promise<string | null> => {
+    if (!isElectron()) return null;
+    return (window as any).desktop.system.browseFolder();
+  },
+
+  /** Whether native folder picker is available */
+  hasNativePicker: isElectron,
+
+  /** Get instance settings (self-hosted / desktop only) */
+  getSettings: () =>
+    api.get<InstanceSettings>(endpoints.system.settings),
+
+  /** Partial update instance settings */
+  updateSettings: (data: Record<string, unknown>) =>
+    api.patch<{ ok: boolean }>(endpoints.system.settings, data),
+
+  /** Delete server configuration */
+  deleteServer: () =>
+    api.delete<{ ok: boolean }>(endpoints.system.settings),
+
+  /** Run system health checks on the configured server */
+  checkServer: (components?: string[]) =>
+    api.post<ServerCheckResult>(endpoints.system.check, {
+      ...(components?.length ? { components } : {}),
+    }),
+
+  /** Install a component on the configured server */
+  installComponent: (component: string, config?: Record<string, unknown>) =>
+    api.post<InstallResultResponse>(endpoints.system.install, {
+      component,
+      ...(config ? { config } : {}),
+    }),
+
+  /** Get the current install session status (or check if one is running) */
+  getInstallSession: (sessionId?: string) =>
+    api.get<SetupSessionInfo>(endpoints.system.installSession, {
+      params: sessionId ? { id: sessionId } : undefined,
+    }),
+};

package/apps/dashboard/src/lib/auth-client.ts

@@ -0,0 +1,54 @@
+import { createAuthClient } from "better-auth/react";
+
+/**
+ * API base URL — auth requests go directly to the dedicated API server.
+ *
+ * Cookies on localhost are shared across ports, so Set-Cookie from :4000
+ * is readable by :3001 (both browser and SSR via `cookies()`).
+ *
+ * In production both services share a common top-level domain
+ * (e.g. api.openship.com / app.openship.com with cookie domain .openship.com).
+ */
+const API_URL = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:4000";
+
+export const authClient = createAuthClient({
+  baseURL: API_URL,
+  fetchOptions: {
+    credentials: "include",
+    // Disable retry to prevent infinite loops on 429
+    retry: {
+      type: "linear",
+      attempts: 0,
+      delay: 0,
+    },
+  },
+});
+
+export const {
+  signIn,
+  signUp,
+  signOut,
+  useSession,
+} = authClient;
+
+/**
+ * Email / password helpers — these are proxy-generated by Better Auth
+ * when the server has emailAndPassword enabled. We access them via
+ * the client object so TypeScript doesn't complain about missing
+ * static properties.
+ */
+export const forgetPassword = (authClient as any).forgetPassword as (
+  opts: { email: string; redirectTo?: string },
+) => Promise<{ error?: { message?: string } }>;
+
+export const resetPassword = (authClient as any).resetPassword as (
+  opts: { newPassword: string; token?: string },
+) => Promise<{ error?: { message?: string } }>;
+
+export const sendVerificationEmail = (authClient as any).sendVerificationEmail as (
+  opts: { email: string; callbackURL?: string },
+) => Promise<{ error?: { message?: string } }>;
+
+export const verifyEmail = (authClient as any).verifyEmail as (
+  opts: { query: { token: string } },
+) => Promise<{ error?: { message?: string } }>;

package/apps/dashboard/src/lib/country.ts

@@ -0,0 +1,25 @@
+/**
+ * Country / flag utilities.
+ *
+ * Uses the `flagcdn.com` CDN to serve flag images by ISO 3166-1 alpha-2 code.
+ */
+
+/** Returns a URL for the country flag image for the given ISO country code. */
+export function getCountryFlagUrl(
+  countryCode: string,
+  size: "16" | "24" | "32" | "48" | "64" | "128" = "24"
+): string {
+  if (!countryCode) return "";
+  return `https://flagcdn.com/${size}x${Math.floor(Number(size) * 0.75)}/${countryCode.toLowerCase()}.png`;
+}
+
+/** Maps a country code to a human-readable name via Intl API. */
+export function getCountryName(countryCode: string, locale = "en"): string {
+  if (!countryCode) return "Unknown";
+  try {
+    const regionNames = new Intl.DisplayNames([locale], { type: "region" });
+    return regionNames.of(countryCode.toUpperCase()) ?? countryCode;
+  } catch {
+    return countryCode;
+  }
+}

package/apps/dashboard/src/lib/server/api.ts

@@ -0,0 +1,140 @@
+import "server-only";
+import { cookies } from "next/headers";
+
+/**
+ * Server-side API client for Next.js server components, layouts, and route handlers.
+ *
+ * Automatically forwards the browser's cookies to the Openship API
+ * so session authentication works transparently.
+ *
+ * Usage:
+ *   import { serverApi } from "@/lib/server/api";
+ *   const projects = await serverApi.get<Project[]>("/projects");
+ */
+
+const BASE_URL = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:4000";
+const DEFAULT_TIMEOUT = 10_000;
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                             */
+/* ------------------------------------------------------------------ */
+
+export class ServerApiError extends Error {
+  constructor(
+    public status: number,
+    public statusText: string,
+    public body: unknown,
+  ) {
+    super(`API ${status}: ${statusText}`);
+    this.name = "ServerApiError";
+  }
+}
+
+type ServerRequestOptions = {
+  body?: unknown;
+  timeout?: number;
+  params?: Record<string, string | number | boolean | undefined>;
+  headers?: Record<string, string>;
+  /** Next.js fetch cache strategy */
+  cache?: RequestCache;
+  /** Next.js revalidation interval in seconds */
+  revalidate?: number;
+};
+
+/* ------------------------------------------------------------------ */
+/*  Core request                                                      */
+/* ------------------------------------------------------------------ */
+
+async function request<T = unknown>(
+  method: string,
+  path: string,
+  opts: ServerRequestOptions = {},
+): Promise<T> {
+  const { body, timeout = DEFAULT_TIMEOUT, params, headers: extraHeaders, cache, revalidate } = opts;
+
+  /* --- Build URL -------------------------------------------------- */
+  const url = new URL(path.startsWith("/") ? path : `/${path}`, BASE_URL);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined) url.searchParams.set(k, String(v));
+    }
+  }
+
+  /* --- Forward cookies -------------------------------------------- */
+  const cookieStore = await cookies();
+  const cookieHeader = cookieStore
+    .getAll()
+    .map((c) => `${c.name}=${c.value}`)
+    .join("; ");
+
+  /* --- Headers ---------------------------------------------------- */
+  const headers: Record<string, string> = {
+    ...extraHeaders,
+    cookie: cookieHeader,
+  };
+
+  if (body && typeof body === "object" && !(body instanceof FormData)) {
+    headers["content-type"] = "application/json";
+  }
+
+  /* --- Timeout ---------------------------------------------------- */
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  /* --- Fetch ------------------------------------------------------ */
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      signal: controller.signal,
+      body:
+        body instanceof FormData
+          ? body
+          : body !== undefined
+            ? JSON.stringify(body)
+            : undefined,
+      ...(cache !== undefined ? { cache } : {}),
+      ...(revalidate !== undefined ? { next: { revalidate } } : {}),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      let parsed: unknown = text;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        /* keep as string */
+      }
+      throw new ServerApiError(res.status, res.statusText, parsed);
+    }
+
+    if (res.status === 204) return undefined as T;
+
+    const ct = res.headers.get("content-type") ?? "";
+    if (ct.includes("application/json")) return (await res.json()) as T;
+    return (await res.text()) as T;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Convenience methods                                               */
+/* ------------------------------------------------------------------ */
+
+export const serverApi = {
+  get: <T = unknown>(path: string, opts?: ServerRequestOptions) =>
+    request<T>("GET", path, opts),
+
+  post: <T = unknown>(path: string, body?: unknown, opts?: ServerRequestOptions) =>
+    request<T>("POST", path, { ...opts, body }),
+
+  put: <T = unknown>(path: string, body?: unknown, opts?: ServerRequestOptions) =>
+    request<T>("PUT", path, { ...opts, body }),
+
+  patch: <T = unknown>(path: string, body?: unknown, opts?: ServerRequestOptions) =>
+    request<T>("PATCH", path, { ...opts, body }),
+
+  delete: <T = unknown>(path: string, opts?: ServerRequestOptions) =>
+    request<T>("DELETE", path, opts),
+} as const;

package/apps/dashboard/src/lib/server/session.ts

@@ -0,0 +1,103 @@
+import "server-only";
+import { cache } from "react";
+import { serverApi, ServerApiError } from "./api";
+
+/**
+ * Session and user types returned by Better Auth's `/api/auth/get-session`.
+ */
+export type Session = {
+  id: string;
+  userId: string;
+  expiresAt: string;
+  token: string;
+  createdAt: string;
+  updatedAt: string;
+  ipAddress?: string;
+  userAgent?: string;
+};
+
+export type User = {
+  id: string;
+  name: string;
+  email: string;
+  emailVerified: boolean;
+  image?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  role: string;
+  autoProvisioned?: boolean;
+};
+
+export type SessionData = { session: Session; user: User };
+
+/**
+ * Get the current session from the API.
+ *
+ * Wrapped with `React.cache()` so multiple server components
+ * calling `getSession()` in the same request share one fetch.
+ *
+ * Returns the session data or `null` if unauthenticated.
+ */
+export const getSession = cache(async (): Promise<SessionData | null> => {
+  const MAX_RETRIES = 3;
+  const RETRY_DELAY = 1000; // ms
+
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const data = await serverApi.get<SessionData>("/api/auth/get-session", {
+        cache: "no-store",
+      });
+      return data;
+    } catch (err) {
+      // 401 = genuinely unauthenticated — no point retrying
+      if (err instanceof ServerApiError && err.status === 401) {
+        return null;
+      }
+      // Network / timeout error — API may be restarting, retry
+      if (attempt < MAX_RETRIES) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY));
+        continue;
+      }
+      // Exhausted retries — return null so the page shows login
+      return null;
+    }
+  }
+  return null;
+});
+
+/* ------------------------------------------------------------------ */
+/*  Deployment info (fetched once, cached in module memory forever)    */
+/* ------------------------------------------------------------------ */
+
+export type DeploymentInfo = {
+  selfHosted: boolean;
+  deployMode: string;
+  authMode: "cloud" | "local" | "none";
+  cloudAuthUrl: string;
+  machineName?: string;
+};
+
+let _deploymentInfo: DeploymentInfo | null = null;
+let _deploymentInfoFetchedAt = 0;
+
+/**
+ * Deployment info is mostly static, but during desktop onboarding
+ * authMode can change from "none" to "cloud" or vice versa.
+ * Re-fetch every 30 seconds so changes take effect quickly.
+ */
+const DEPLOYMENT_INFO_TTL = 30_000;
+
+export async function getDeploymentInfo(): Promise<DeploymentInfo> {
+  if (_deploymentInfo && Date.now() - _deploymentInfoFetchedAt < DEPLOYMENT_INFO_TTL) {
+    return _deploymentInfo;
+  }
+  try {
+    _deploymentInfo = await serverApi.get<DeploymentInfo>("/api/health/env");
+    _deploymentInfoFetchedAt = Date.now();
+  } catch {
+    if (!_deploymentInfo) {
+      _deploymentInfo = { selfHosted: true, deployMode: "docker", authMode: "local", cloudAuthUrl: "" };
+    }
+  }
+  return _deploymentInfo;
+}