openship 0.1.1 → 0.1.7

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

@@ -1,21 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

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

@@ -1,140 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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;
-}