openship 0.1.1 → 0.1.8

package/packages/adapters/src/toolchain/installer.ts

@@ -1,189 +0,0 @@
-/**
- * Toolchain installers — install language runtimes on bare metal.
- *
- * Same pattern as system/installer.ts:
- *   1. Resolve environment profile (OS, arch, package manager)
- *   2. Get install plan from catalog
- *   3. Stream the install command output
- *   4. Verify installation
- *
- * Installs run sequentially — dependencies first (e.g. ruby before bundler).
- * Tools with `providedBy` are skipped if their parent was just installed.
- */
-
-import type { CommandExecutor, LogEntry } from "../types";
-import type { ToolchainInstallResult } from "./types";
-import { toolchainCatalog } from "./catalog";
-import { checkTool } from "./checks";
-import { resolveEnvironment } from "../system/environment";
-import { systemDebug, formatDuration } from "../system/debug";
-
-// ─── Single tool install ────────────────────────────────────────────────────
-
-/**
- * Install a single tool. Streams output via onLog callback.
- * Returns the install result (success/failure + version).
- */
-export async function installTool(
-  executor: CommandExecutor,
-  name: string,
-  onLog?: (log: LogEntry) => void,
-  requiredVersion?: string,
-): Promise<ToolchainInstallResult> {
-  const startedAt = Date.now();
-  const recipe = toolchainCatalog.checks[name];
-
-  if (!recipe) {
-    return { tool: name, success: false, error: `Unknown tool: ${name}` };
-  }
-
-  // If tool is provided by a parent, check if it's already available
-  // (parent install may have brought it in)
-  if (recipe.providedBy && !toolchainCatalog.installs[name]) {
-    const status = await checkTool(executor, name, { minVersion: requiredVersion });
-    if (status.healthy) {
-      return { tool: name, success: true, version: status.version };
-    }
-    return {
-      tool: name,
-      success: false,
-      error: `${recipe.label} should be installed by ${recipe.providedBy}`,
-    };
-  }
-
-  const factory = toolchainCatalog.installs[name];
-  if (!factory) {
-    return { tool: name, success: false, error: `No installer for ${name}` };
-  }
-
-  const profile = await resolveEnvironment(executor);
-  const plan = factory(profile);
-
-  if (!plan.supported) {
-    const msg = plan.unsupportedReason ?? `${recipe.label} installation not supported on this system`;
-    onLog?.({
-      timestamp: new Date().toISOString(),
-      message: msg,
-      level: "error",
-    });
-    return { tool: name, success: false, error: msg };
-  }
-
-  systemDebug("toolchain", `install:start ${name}`);
-  onLog?.({
-    timestamp: new Date().toISOString(),
-    message: `Installing ${recipe.label}...`,
-    level: "info",
-  });
-
-  try {
-    // Run the install command with streaming output
-    const { code } = await executor.streamExec(plan.installCommand!, (entry) => {
-      onLog?.(entry);
-    });
-
-    if (code !== 0) {
-      // Try fallback commands if available
-      if (plan.fallbackInstallCommands?.length) {
-        for (const fallback of plan.fallbackInstallCommands) {
-          onLog?.({
-            timestamp: new Date().toISOString(),
-            message: `Primary install failed, trying fallback...`,
-            level: "warn",
-          });
-          const fb = await executor.streamExec(fallback, (entry) => onLog?.(entry));
-          if (fb.code === 0) break;
-        }
-      } else {
-        throw new Error(`Install command failed with exit code ${code}`);
-      }
-    }
-
-    // Run start command if needed
-    if (plan.startCommand) {
-      await executor.streamExec(plan.startCommand, (entry) => onLog?.(entry));
-    }
-
-    // Verify installation
-    const verifyCmd = plan.verifyCommand ?? recipe.versionCommand;
-    const verifyResult = await executor.exec(verifyCmd, { timeout: 10_000 }).catch(() => null);
-
-    if (!verifyResult) {
-      throw new Error(`${recipe.label} installed but verification failed`);
-    }
-
-    const version = recipe.parseVersion(verifyResult);
-    systemDebug("toolchain", `install:done ${name} v${version} (${formatDuration(startedAt)})`);
-
-    onLog?.({
-      timestamp: new Date().toISOString(),
-      message: `${recipe.label} ${version} installed successfully`,
-      level: "info",
-    });
-
-    return { tool: name, success: true, version };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    systemDebug("toolchain", `install:fail ${name} (${formatDuration(startedAt)}) ${msg}`);
-
-    onLog?.({
-      timestamp: new Date().toISOString(),
-      message: `Failed to install ${recipe.label}: ${msg}`,
-      level: "error",
-    });
-
-    return { tool: name, success: false, error: msg };
-  }
-}
-
-// ─── Batch install ──────────────────────────────────────────────────────────
-
-/**
- * Install multiple tools sequentially. Respects dependency order:
- * parent tools (node, ruby, python3) are installed before their
- * children (npm, bundler, pip).
- *
- * Returns results for each tool.
- */
-export async function installTools(
-  executor: CommandExecutor,
-  toolNames: readonly string[],
-  onLog?: (log: LogEntry) => void,
-  requiredVersions?: Readonly<Record<string, string>>,
-): Promise<ToolchainInstallResult[]> {
-  // Sort: parent tools first, children after
-  const sorted = [...toolNames].sort((a, b) => {
-    const aEntry = toolchainCatalog.checks[a];
-    const bEntry = toolchainCatalog.checks[b];
-    // Tools with providedBy go after their parent
-    if (aEntry?.providedBy === b) return 1;
-    if (bEntry?.providedBy === a) return -1;
-    // Installable tools first
-    if (aEntry?.installable && !bEntry?.installable) return -1;
-    if (!aEntry?.installable && bEntry?.installable) return 1;
-    return 0;
-  });
-
-  const results: ToolchainInstallResult[] = [];
-
-  for (const name of sorted) {
-    // Skip if already healthy (e.g. parent install brought it in)
-    const status = await checkTool(executor, name, {
-      minVersion: requiredVersions?.[name],
-    });
-    if (status.healthy) {
-      onLog?.({
-        timestamp: new Date().toISOString(),
-        message: `${status.label} ${status.version ?? ""} already installed, skipping`,
-        level: "info",
-      });
-      results.push({ tool: name, success: true, version: status.version });
-      continue;
-    }
-
-    const result = await installTool(executor, name, onLog, requiredVersions?.[name]);
-    results.push(result);
-  }
-
-  return results;
-}

package/packages/adapters/src/toolchain/types.ts

@@ -1,84 +0,0 @@
-/**
- * Toolchain types — stack-level tool validation and installation.
- *
- * The toolchain layer ensures a bare-metal server has the right
- * language runtimes installed BEFORE a build starts. It mirrors
- * the system component catalog (Docker/Traefik/Git) but for
- * language-specific tools (Node, Go, Rust, Python, etc.).
- *
- * The source of truth for WHICH tools a language needs lives in
- * `@repo/core` → `LANGUAGES[lang].requiredTools`. This layer
- * provides HOW to check and install them.
- */
-
-// ─── Tool status ─────────────────────────────────────────────────────────────
-
-export interface ToolchainStatus {
-  /** Tool identifier (e.g. "node", "go", "rustc") */
-  name: string;
-  /** Human-readable label (e.g. "Node.js", "Go", "Rust compiler") */
-  label: string;
-  /** Whether the tool is installed and available */
-  installed: boolean;
-  /** Detected version string */
-  version?: string;
-  /** Minimum required version for this stack/toolchain check */
-  requiredVersion?: string;
-  /** Ready to use */
-  healthy: boolean;
-  /** Human-readable status message */
-  message: string;
-}
-
-// ─── Aggregate result ────────────────────────────────────────────────────────
-
-export interface ToolchainCheckResult {
-  /** Status of each required tool */
-  tools: ToolchainStatus[];
-  /** All tools present and healthy */
-  ready: boolean;
-  /** Names of missing tools */
-  missing: string[];
-  /** Names of installed but too-old tools */
-  outdated: string[];
-}
-
-// ─── Catalog entry types ─────────────────────────────────────────────────────
-
-/** Recipe for checking whether a tool is installed. */
-export interface ToolchainCheckEntry {
-  /** Human-readable label */
-  label: string;
-  /** Shell command to detect the tool + version */
-  versionCommand: string;
-  /** Extract a clean version string from command output */
-  parseVersion: (output: string) => string;
-  /** Message when the tool is not found */
-  missingMessage: string;
-  /**
-   * Whether this tool can be auto-installed.
-   * Some tools (npm, cargo, mix) ship with their parent — no separate install.
-   */
-  installable: boolean;
-  /** Parent tool that provides this one (e.g. "npm" → "node") */
-  providedBy?: string;
-}
-
-/** Plan for installing a tool — same shape as system catalog. */
-export interface ToolchainInstallPlan {
-  supported: boolean;
-  unsupportedReason?: string;
-  installCommand?: string;
-  startCommand?: string;
-  verifyCommand?: string;
-  fallbackInstallCommands?: string[];
-}
-
-// ─── Install result ──────────────────────────────────────────────────────────
-
-export interface ToolchainInstallResult {
-  tool: string;
-  success: boolean;
-  version?: string;
-  error?: string;
-}

package/packages/adapters/src/types.ts

@@ -1,277 +0,0 @@
-/**
- * Shared types used across all adapter layers.
- *
- * These are pure data types — no adapter interfaces here.
- * Resource configs, build/deploy configs, log entries, container info,
- * routing configs, and SSL results.
- */
-
-// ─── Resource configuration ──────────────────────────────────────────────────
-
-export interface ResourceConfig {
-  /** CPU cores (fractional, e.g. 0.5, 1.0, 2.0) — the universal unit all runtimes use */
-  cpuCores: number;
-  /** Memory limit in megabytes */
-  memoryMb: number;
-  /** Writable disk in megabytes */
-  diskMb: number;
-}
-
-/** Single source of truth — production resources */
-export const DEFAULT_RESOURCE_CONFIG: ResourceConfig = {
-  cpuCores: 1,
-  memoryMb: 512,
-  diskMb: 4096,
-};
-
-/** Single source of truth — build resources */
-export const DEFAULT_BUILD_RESOURCE_CONFIG: ResourceConfig = {
-  cpuCores: 2,
-  memoryMb: 4096,
-  diskMb: 10240,
-};
-
-// ─── Build / Deploy types ────────────────────────────────────────────────────
-
-export type ContainerStatus =
-  | "queued"
-  | "building"
-  | "deploying"
-  | "running"
-  | "stopped"
-  | "failed"
-  | "cancelled";
-
-export type BuildStrategy = "server" | "local";
-
-export interface BuildConfig {
-  /** Unique build session id */
-  sessionId: string;
-  /** Project identifier */
-  projectId: string;
-  /** URL slug for the project (e.g. "my-app") */
-  slug?: string;
-  /** Git repo clone URL (required when source is a git repo) */
-  repoUrl: string;
-  /** Branch to build */
-  branch: string;
-  /** Commit SHA (optional, defaults to HEAD) */
-  commitSha?: string;
-  /** Absolute path to a local project directory (used instead of repoUrl for local projects) */
-  localPath?: string;
-  /** Where the build runs: "server" (clone/copy to workspace) or "local" (build on host, transfer dist) */
-  buildStrategy?: BuildStrategy;
-  /** Detected framework / stack */
-  stack: string;
-  /** Docker image for the build container (e.g. "node:22", "oven/bun:latest") */
-  buildImage: string;
-  /** Package manager (npm | yarn | pnpm | bun) */
-  packageManager: string;
-  /** Shell command to install dependencies */
-  installCommand: string;
-  /** Shell command to build the project */
-  buildCommand: string;
-  /** Output directory to collect after build */
-  outputDirectory: string;
-  /** Environment variables injected at build time */
-  envVars: Record<string, string>;
-  /** Resources allocated for the build container */
-  resources: ResourceConfig;
-  /** Ephemeral token for cloning private repos — never persisted */
-  gitToken?: string;
-}
-
-export interface DeployConfig {
-  /** Unique deployment id */
-  deploymentId: string;
-  /** Project identifier */
-  projectId: string;
-  /** Reference to the completed build session */
-  buildSessionId: string;
-  /** Opaque reference to the built artifact (workspace ID, docker image tag, etc.) */
-  imageRef?: string;
-  /** "production" | "preview" */
-  environment: string;
-  /** Port the application listens on */
-  port: number;
-  /** Shell command to start the application (e.g. "npm start", "node server.js") */
-  startCommand?: string;
-  /** Detected framework / stack (e.g. "nextjs", "express") */
-  stack?: string;
-  /** Environment variables injected at runtime */
-  envVars: Record<string, string>;
-  /** Resources allocated for the production container */
-  resources: ResourceConfig;
-  /** Container restart policy */
-  restartPolicy?: "always" | "on-failure" | "no";
-  /** URL slug for the deployment (e.g. "my-app" → my-app.opsh.io) */
-  slug?: string;
-  /** Custom domain to bind via DNS (e.g. "app.example.com") — separate from free subdomain */
-  customDomain?: string;
-  /** Files/directories to copy into /app/production/ before starting the workload.
-   *  When set, the workload runs from /app/production/ instead of /app/. */
-  productionPaths?: string[];
-}
-
-export interface BuildResult {
-  sessionId: string;
-  status: ContainerStatus;
-  /** Opaque reference to the built image / snapshot */
-  imageRef?: string;
-  durationMs?: number;
-}
-
-export interface DeploymentResult {
-  deploymentId: string;
-  containerId?: string;
-  url?: string;
-  status: ContainerStatus;
-}
-
-/** Pipeline step identifiers for stepper UI */
-export type BuildStep = "clone" | "install" | "build" | "deploy";
-
-export const BUILD_STEPS: readonly BuildStep[] = ["clone", "install", "build", "deploy"] as const;
-
-export interface LogEntry {
-  timestamp: string;
-  message: string;
-  level: "info" | "warn" | "error";
-  /** When present, this entry is a step event for the stepper UI */
-  step?: BuildStep;
-  /** Step lifecycle status */
-  stepStatus?: "running" | "completed" | "failed" | "skipped";
-  /** Pre-encoded base64 data — passed through to SSE without re-encoding. */
-  rawData?: string;
-}
-
-export interface ContainerInfo {
-  containerId: string;
-  status: ContainerStatus;
-  /** Container IP on the internal network */
-  ip?: string;
-  /** Mapped port on host (if applicable) */
-  hostPort?: number;
-  /** Uptime in seconds */
-  uptimeSeconds?: number;
-  /** Current resource consumption */
-  usage?: ResourceUsage;
-}
-
-export interface ResourceUsage {
-  cpuPercent: number;
-  memoryMb: number;
-  diskMb: number;
-  networkRxBytes: number;
-  networkTxBytes: number;
-}
-
-export interface RouteConfig {
-  /** External domain (e.g. "my-app.example.com") */
-  domain: string;
-  /** Target container IP + port */
-  targetUrl: string;
-  /** Whether TLS is enabled */
-  tls: boolean;
-}
-
-export interface SslResult {
-  domain: string;
-  expiresAt: string;
-  issuer: string;
-}
-
-// ─── Log streaming callback ──────────────────────────────────────────────────
-
-export type LogCallback = (entry: LogEntry) => void;
-
-// ─── SSH configuration ──────────────────────────────────────────────────────
-
-/**
- * SSH connection configuration — shared across layers.
- *
- * Used by:
- *   - System layer: execute setup commands on remote servers
- *   - Infra layer: write Traefik config on remote servers
- *   - Platform: wires SSH config to both layers
- *
- * Security:
- *   - Supports private key, SSH agent, or password auth
- *   - Private keys should be encrypted at rest, decrypted in memory
- */
-export interface SshConfig {
-  host: string;
-  port?: number;
-  username?: string;
-  /** SSH password for password-based auth */
-  password?: string;
-  /** Decrypted PEM private key — never stored in plaintext on disk */
-  privateKey?: string;
-  /** Passphrase for the key (if the PEM itself is encrypted) */
-  privateKeyPassphrase?: string;
-  /** SSH agent socket (alternative to privateKey) */
-  sshAgent?: string;
-}
-
-// ─── Command execution abstraction ──────────────────────────────────────────
-
-/**
- * Abstraction for running commands and file operations on a target machine.
- *
- * Two implementations:
- *   - LocalExecutor  → child_process + fs (same machine)
- *   - SshExecutor    → ssh2 (remote server)
- *
- * Used by the system layer (checks, installers) and infra layer (Traefik
- * config writes) to support both local and remote server management.
- */
-export interface CommandExecutor {
-  /** Run a command, resolve to stdout. Rejects on non-zero exit. */
-  exec(command: string, opts?: { timeout?: number }): Promise<string>;
-
-  /**
-   * Run a command with real-time log streaming.
-   * Resolves when the command exits — the log callback fires for each line.
-   */
-  streamExec(
-    command: string,
-    onLog: (log: LogEntry) => void,
-  ): Promise<{ code: number; output: string }>;
-
-  /** Write content to a file on the target machine. Creates dirs as needed. */
-  writeFile(path: string, content: string): Promise<void>;
-
-  /** Read a file from the target machine. */
-  readFile(path: string): Promise<string>;
-
-  /** Check if a file or directory exists. */
-  exists(path: string): Promise<boolean>;
-
-  /** Create a directory (recursive). */
-  mkdir(path: string): Promise<void>;
-
-  /** Remove a file or directory recursively. Silently succeeds if already gone. */
-  rm(path: string): Promise<void>;
-
-  /**
-   * Transfer a local directory into the target environment.
-   *
-   * LocalExecutor: cp -a (same filesystem).
-   * SshExecutor:   tar locally → pipe through SSH → extract remotely.
-   *
-   * By default SshExecutor excludes `node_modules` and `.git` (source transfer).
-   * Pass `options.excludes` to override (e.g. `[]` to include everything for
-   * build output transfer).
-   *
-   * Rejects on failure.
-   */
-  transferIn(
-    localPath: string,
-    remotePath: string,
-    onLog?: (log: LogEntry) => void,
-    options?: { excludes?: string[] },
-  ): Promise<void>;
-
-  /** Clean up connections / resources. */
-  dispose(): Promise<void>;
-}

package/packages/adapters/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "lib": ["ES2022"],
-    "types": ["node"],
-    "outDir": "dist"
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}

package/packages/core/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "@repo/core",
-  "version": "0.1.0",
-  "type": "module",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
-  "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
-    }
-  },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "lint": "tsc --noEmit",
-    "clean": "rm -rf dist .turbo node_modules"
-  },
-  "dependencies": {
-    "zod": "^4.3.6"
-  },
-  "devDependencies": {
-    "@types/node": "^22.13.0",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3"
-  }
-}

package/packages/core/src/constants.ts

@@ -1,71 +0,0 @@
-/**
- * Shared constants used across the monorepo.
- */
-
-export const APP_NAME = "Openship";
-
-export const DEFAULT_PORT = {
-  web: 3000,
-  dashboard: 3001,
-  api: 4000,
-} as const;
-
-export const DEPLOYMENT_STATUSES = [
-  "queued",
-  "building",
-  "deploying",
-  "ready",
-  "failed",
-  "cancelled",
-] as const;
-
-/**
- * Re-export from stacks registry — STACK_IDS replaces the old FRAMEWORKS array.
- * Import { STACK_IDS } or { STACKS } from "@repo/core" instead.
- */
-export { STACK_IDS as FRAMEWORKS } from "./stacks";
-
-export const PRODUCTION_MODES = ["host", "static", "standalone"] as const;
-
-export const ENVIRONMENTS = ["production", "preview", "development"] as const;
-
-export const DOMAIN_STATUSES = ["pending", "active", "failed", "removing"] as const;
-
-export const SSL_STATUSES = ["none", "provisioning", "active", "expired", "error"] as const;
-
-/**
- * Non-interactive environment variables injected into every build container.
- * Prevents interactive prompts and disables telemetry during CI builds.
- */
-export const BUILD_ENV_VARS: Record<string, string> = {
-  CI: "true",
-  DEBIAN_FRONTEND: "noninteractive",
-  // Force color output even without a TTY (exec API uses pipes, not PTY)
-  FORCE_COLOR: "1",
-  TERM: "xterm-256color",
-  // Framework telemetry
-  NG_CLI_ANALYTICS: "false",
-  NEXT_TELEMETRY_DISABLED: "1",
-  NUXT_TELEMETRY_DISABLED: "1",
-  ASTRO_TELEMETRY_DISABLED: "1",
-  GATSBY_TELEMETRY_DISABLED: "1",
-  DO_NOT_TRACK: "1",
-  // Package manager
-  NPM_CONFIG_UPDATE_NOTIFIER: "false",
-  NPM_CONFIG_AUDIT: "false",
-  NPM_CONFIG_FUND: "false",
-  YARN_ENABLE_TELEMETRY: "0",
-  PNPM_NO_UPDATE_NOTIFIER: "true",
-  GIT_TERMINAL_PROMPT: "0",
-};
-
-/**
- * Re-export from stacks registry — OUTPUT_DIRECTORIES is derived from STACKS.
- */
-export { OUTPUT_DIRECTORIES } from "./stacks";
-
-export const PLANS = {
-  free: { name: "Free", price: 0, buildMinutes: 100, bandwidth: 1 },
-  pro: { name: "Pro", price: 20, buildMinutes: 1000, bandwidth: 100 },
-  team: { name: "Team", price: 50, buildMinutes: 5000, bandwidth: 500 },
-} as const;