openship 0.1.1 → 0.1.8

package/packages/adapters/src/runtime/local-build.ts

@@ -1,112 +0,0 @@
-/**
- * Shared local build — build on the API host, then hand off output.
- *
- * When buildStrategy="local", both BareRuntime and CloudRuntime need
- * the same sequence:
- *   1. Create a temporary build directory on the API host
- *   2. Set up a BuildEnvironment backed by a LocalExecutor
- *   3. Run the shared pipeline (clone → install → build)
- *   4. Let the runtime transfer the output to the target (SSH / cloud upload)
- *   5. Clean up the local build directory
- *
- * This module encapsulates steps 1-5 so each runtime only provides
- * the transfer callback and optional preflight hooks.
- */
-
-import type { BuildConfig, CommandExecutor } from "../types";
-import { LocalExecutor } from "../system/executor";
-import {
-  BuildLogger,
-  runBuildPipeline,
-  type BuildEnvironment,
-  type BuildPipelineResult,
-} from "./build-pipeline";
-import { transferLocalDirectory } from "./transfer";
-
-const LOCAL_BUILD_DIR = "/tmp/openship/.builds";
-
-// ─── Options ─────────────────────────────────────────────────────────────────
-
-export interface LocalBuildOptions {
-  config: BuildConfig;
-  logger: BuildLogger;
-
-  /** AbortSignal for build cancellation. */
-  abort?: AbortSignal;
-
-  /**
-   * Extra preflight logic that runs before the shared pipeline.
-   * Receives the local executor so callers can run toolchain checks, etc.
-   */
-  preflight?: (
-    config: BuildConfig,
-    logger: BuildLogger,
-    localExec: CommandExecutor,
-  ) => Promise<void>;
-
-  /**
-   * Called after a successful build with the path to the local build output.
-   * Transfer/upload the output to the target here (SSH, Oblien API, etc.).
-   * Runs BEFORE cleanup of the local build directory.
-   */
-  transferOutput: (buildDir: string) => Promise<void>;
-}
-
-// ─── Runner ──────────────────────────────────────────────────────────────────
-
-export async function runLocalBuild(
-  opts: LocalBuildOptions,
-): Promise<BuildPipelineResult> {
-  const { config, logger, abort } = opts;
-  const localExec = new LocalExecutor();
-  const buildDir = `${LOCAL_BUILD_DIR}/${config.sessionId}`;
-
-  await localExec.rm(buildDir);
-  await localExec.mkdir(buildDir);
-
-  const buildEnv: BuildEnvironment = {
-    projectDir: buildDir,
-    exec: async (command, logCb) => {
-      if (abort?.aborted) throw new Error("Build cancelled");
-      const { code } = await localExec.streamExec(command, logCb);
-      if (abort?.aborted) throw new Error("Build cancelled");
-      if (code !== 0) {
-        throw new Error(`Command failed with exit code ${code}`);
-      }
-    },
-    preflight: async (cfg, plog) => {
-      if (abort?.aborted) throw new Error("Build cancelled");
-
-      // Runtime-specific preflight (toolchain checks, etc.)
-      if (opts.preflight) {
-        await opts.preflight(cfg, plog, localExec);
-      }
-
-      // Transfer local project source into the build directory
-      if (cfg.localPath) {
-        await transferLocalDirectory(
-          cfg.localPath,
-          {
-            kind: "executor",
-            executor: localExec,
-            path: buildDir,
-          },
-          plog,
-        );
-      }
-    },
-  };
-
-  try {
-    const result = await runBuildPipeline(buildEnv, config, logger);
-
-    if (result.status === "deploying") {
-      await opts.transferOutput(buildDir);
-    }
-
-    return result;
-  } finally {
-    await localExec.rm(buildDir).catch(() => {});
-    await localExec.dispose();
-  }
-}

package/packages/adapters/src/runtime/transfer.ts

@@ -1,82 +0,0 @@
-import { execFile } from "node:child_process";
-
-import type { WorkspaceHandle } from "oblien";
-
-import type { CommandExecutor } from "../types";
-import { BuildLogger } from "./build-pipeline";
-
-export interface DirectoryTransferOptions {
-  excludes?: string[];
-}
-
-export type LocalDirectoryTarget =
-  | {
-      kind: "executor";
-      executor: CommandExecutor;
-      path: string;
-    }
-  | {
-      kind: "cloud-runtime";
-      runtime: Awaited<ReturnType<WorkspaceHandle["runtime"]>>;
-      path: string;
-    };
-
-const DEFAULT_SOURCE_EXCLUDES = ["node_modules", ".git"] as const;
-const TAR_MAX_BUFFER = 500 * 1024 * 1024;
-
-export async function transferLocalDirectory(
-  localPath: string,
-  target: LocalDirectoryTarget,
-  logger: BuildLogger,
-  options?: DirectoryTransferOptions,
-): Promise<void> {
-  logger.log(`Transferring ${localPath} → ${target.path}...\n`);
-
-  if (target.kind === "executor") {
-    await target.executor.transferIn(localPath, target.path, logger.callback, options);
-    logger.log("Transfer complete.\n");
-    return;
-  }
-
-  const tarBuffer = await createTarball(localPath, options);
-  const result = await target.runtime.transfer.upload({
-    body: tarBuffer,
-    dest: target.path,
-  });
-
-  logger.log(`Uploaded ${result.files_extracted} files.\n`);
-}
-
-async function createTarball(
-  localPath: string,
-  options?: DirectoryTransferOptions,
-): Promise<Buffer> {
-  const excludes = options?.excludes ?? [...DEFAULT_SOURCE_EXCLUDES];
-  const args = ["czf", "-", "-C", localPath];
-
-  for (const exclude of excludes) {
-    args.push(`--exclude=${exclude}`);
-  }
-
-  args.push(".");
-
-  return new Promise((resolve, reject) => {
-    execFile(
-      "tar",
-      args,
-      {
-        encoding: "buffer",
-        maxBuffer: TAR_MAX_BUFFER,
-      },
-      (err, stdout, stderr) => {
-        if (err) {
-          const stderrText = Buffer.isBuffer(stderr) ? stderr.toString().trim() : String(stderr ?? "").trim();
-          reject(new Error(stderrText || err.message));
-          return;
-        }
-
-        resolve(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
-      },
-    );
-  });
-}

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

@@ -1,138 +0,0 @@
-/**
- * Runtime adapter interface — build/deploy/observe lifecycle.
- *
- * This is the ONLY concern of the runtime layer: managing containers or
- * processes. Routing, SSL, and system setup are handled by other layers.
- *
- * Three implementations:
- *   - DockerRuntime → Docker Engine via dockerode
- *   - BareRuntime   → Direct processes via child_process
- *   - CloudRuntime  → Oblien cloud API
- */
-
-import type {
-  BuildConfig,
-  DeployConfig,
-  BuildResult,
-  DeploymentResult,
-  LogEntry,
-  LogCallback,
-  ContainerInfo,
-  ResourceUsage,
-} from "../types";
-import type { BuildLogger } from "./build-pipeline";
-
-// ─── Capabilities ────────────────────────────────────────────────────────────
-
-/**
- * Features a runtime may or may not support.
- *
- * Service code checks `runtime.supports("containerInfo")` before calling
- * `runtime.getContainerInfo(...)`. This lets every runtime declare what
- * it actually implements — callers never hit a silent stub.
- */
-export type RuntimeCapability =
-  | "build"
-  | "deploy"
-  | "stop"
-  | "start"
-  | "restart"
-  | "destroy"
-  | "containerInfo"
-  | "runtimeLogs"
-  | "streamLogs"
-  | "usage"
-  | "containerIp";
-
-// ─── Interface ───────────────────────────────────────────────────────────────
-
-export interface RuntimeAdapter {
-  /** Human-readable name of the runtime */
-  readonly name: string;
-
-  /** Set of capabilities this runtime actually implements */
-  readonly capabilities: ReadonlySet<RuntimeCapability>;
-
-  /** Check if a specific feature is supported */
-  supports(cap: RuntimeCapability): boolean;
-
-  /** Clean up any resources held by the runtime (connections, temp files) */
-  dispose?(): Promise<void>;
-
-  // ── Build lifecycle ──────────────────────────────────────────────────
-
-  /**
-   * Execute a build (clone repo, install, build).
-   * Docker: runs inside an isolated container.
-   * Bare: runs on the host via shell commands.
-   * Cloud: delegates to cloud build infrastructure.
-   */
-  build(config: BuildConfig, logger?: BuildLogger): Promise<BuildResult>;
-
-  /** Cancel an in-progress build */
-  cancelBuild(sessionId: string): Promise<void>;
-
-  /** Retrieve build logs (for builds that already completed) */
-  getBuildLogs(sessionId: string): Promise<LogEntry[]>;
-
-  // ── Deploy lifecycle ─────────────────────────────────────────────────
-
-  /** Start a container/process from a completed build */
-  deploy(config: DeployConfig, onLog?: LogCallback): Promise<DeploymentResult>;
-
-  /** Stop a running container/process (preserves state) */
-  stop(containerId: string): Promise<void>;
-
-  /** Start a previously stopped container/process */
-  start(containerId: string): Promise<void>;
-
-  /** Restart a container/process */
-  restart(containerId: string): Promise<void>;
-
-  /** Permanently remove a container/process and its resources */
-  destroy(containerId: string): Promise<void>;
-
-  // ── Observability ────────────────────────────────────────────────────
-
-  /** Get the current status and metadata */
-  getContainerInfo(containerId: string): Promise<ContainerInfo>;
-
-  /** Get runtime logs */
-  getRuntimeLogs(containerId: string, tail?: number): Promise<LogEntry[]>;
-
-  /**
-   * Stream runtime logs in real-time via callback.
-   * Returns a cleanup function to stop the stream.
-   */
-  streamRuntimeLogs(
-    containerId: string,
-    onLog: LogCallback,
-    opts?: { tail?: number },
-  ): Promise<() => void>;
-
-  /** Get current resource usage metrics */
-  getUsage(containerId: string): Promise<ResourceUsage>;
-
-  // ── Network ──────────────────────────────────────────────────────────
-
-  /** Resolve the internal IP address of a container/process */
-  getContainerIp(containerId: string): Promise<string | null>;
-}
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-/**
- * Assert that a runtime supports a capability before calling it.
- * Throws a descriptive error if the feature is not available.
- */
-export function assertCapability(
-  runtime: RuntimeAdapter,
-  cap: RuntimeCapability,
-): void {
-  if (!runtime.supports(cap)) {
-    throw new Error(
-      `Runtime "${runtime.name}" does not support "${cap}". ` +
-        `Supported: ${[...runtime.capabilities].join(", ")}`,
-    );
-  }
-}

package/packages/adapters/src/system/catalog.ts

@@ -1,188 +0,0 @@
-import type { InstallerConfig } from "./types";
-import type { EnvironmentProfile } from "./environment";
-
-export interface ComponentCheckCatalogEntry {
-  versionCommand: string;
-  parseVersion: (output: string) => string;
-  daemonCommand?: string;
-  runningCommands?: string[];
-  missingMessage: string;
-  notRunningMessage?: string;
-}
-
-export interface InstallPlan {
-  supported: boolean;
-  unsupportedReason?: string;
-  installCommand?: string;
-  startCommand?: string;
-  verifyCommand?: string;
-  fallbackInstallCommands?: string[];
-}
-
-function dockerInstallPlan(profile: EnvironmentProfile): InstallPlan {
-  if (profile.os !== "linux") {
-    return {
-      supported: false,
-      unsupportedReason: "Docker installation is only supported on Linux servers",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand: "curl -fsSL https://get.docker.com | sh",
-    startCommand:
-      profile.serviceManager === "systemd"
-        ? "systemctl enable docker && systemctl start docker"
-        : undefined,
-    verifyCommand: "docker --version",
-  };
-}
-
-function gitInstallPlan(profile: EnvironmentProfile): InstallPlan {
-  const commands: Record<string, string> = {
-    apt: "apt-get update -qq && apt-get install -y -qq git",
-    dnf: "dnf install -y git",
-    yum: "yum install -y git",
-    brew: "brew install git",
-  };
-
-  const installCommand = commands[profile.packageManager];
-  if (!installCommand) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for Git installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand,
-    verifyCommand: "git --version",
-  };
-}
-
-function nodeInstallPlan(profile: EnvironmentProfile): InstallPlan {
-  if (profile.packageManager === "apt") {
-    return {
-      supported: true,
-      installCommand:
-        "curl -fsSL https://deb.nodesource.com/setup_lts.x | bash - && apt-get install -y nodejs",
-      verifyCommand: "node --version",
-    };
-  }
-
-  const fallbacks: Record<string, string> = {
-    dnf: "dnf install -y nodejs",
-    yum: "yum install -y nodejs",
-    brew: "brew install node",
-  };
-
-  const fallback = fallbacks[profile.packageManager];
-  if (!fallback) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for Node.js installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand: fallback,
-    verifyCommand: "node --version",
-  };
-}
-
-function traefikDockerPlan(
-  _profile: EnvironmentProfile,
-  config?: InstallerConfig,
-): InstallPlan {
-  const acmeEmail = config?.acmeEmail ?? "admin@localhost";
-  const args = [
-    "docker run -d",
-    "--name traefik",
-    "--restart unless-stopped",
-    "--network host",
-    "-v /var/run/docker.sock:/var/run/docker.sock:ro",
-    "-v /etc/traefik:/etc/traefik",
-    "traefik:v3.4",
-    "--providers.file.directory=/etc/traefik/dynamic",
-    "--providers.file.watch=true",
-    "--entrypoints.web.address=:80",
-    "--entrypoints.websecure.address=:443",
-    `--certificatesresolvers.letsencrypt.acme.email=${acmeEmail}`,
-    "--certificatesresolvers.letsencrypt.acme.storage=/etc/traefik/acme/acme.json",
-    "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web",
-  ];
-
-  return {
-    supported: true,
-    installCommand: "docker pull traefik:v3.4",
-    startCommand: args.join(" "),
-    verifyCommand: "traefik version --format json 2>/dev/null || traefik version 2>/dev/null || echo unknown",
-  };
-}
-
-function traefikBinaryPlan(profile: EnvironmentProfile): InstallPlan {
-  if (profile.os !== "linux") {
-    return {
-      supported: false,
-      unsupportedReason: "Traefik binary installation is only supported on Linux servers",
-    };
-  }
-
-  const arch = profile.arch === "arm64" ? "arm64" : "amd64";
-  const url = `https://github.com/traefik/traefik/releases/latest/download/traefik_linux_${arch}`;
-
-  return {
-    supported: true,
-    installCommand:
-      `curl -fsSL -o /tmp/traefik \"${url}\" && chmod +x /tmp/traefik && mv /tmp/traefik /usr/local/bin/traefik`,
-    verifyCommand: "traefik version 2>/dev/null || echo unknown",
-  };
-}
-
-export const systemCatalog = {
-  checks: {
-    docker: {
-      versionCommand: "docker --version",
-      daemonCommand: "docker info --format '{{.ServerVersion}}'",
-      parseVersion: (output: string) =>
-        output.match(/Docker version ([^\s,]+)/)?.[1] ?? output,
-      missingMessage: "Docker is not installed",
-      notRunningMessage: "Docker is installed but the daemon is not running",
-    },
-    traefik: {
-      versionCommand: "traefik version --format json 2>/dev/null",
-      runningCommands: [
-        "pgrep -x traefik",
-        "docker ps --filter name=traefik --format '{{.Names}}' 2>/dev/null",
-      ],
-      parseVersion: (output: string) => {
-        try {
-          return JSON.parse(output).Version;
-        } catch {
-          return output.match(/Version:\s*(\S+)/)?.[1] ?? output;
-        }
-      },
-      missingMessage: "Traefik is not installed",
-      notRunningMessage: "Traefik is installed but not running",
-    },
-    git: {
-      versionCommand: "git --version",
-      parseVersion: (output: string) => output.match(/git version (\S+)/)?.[1] ?? output,
-      missingMessage: "Git is not installed",
-    },
-    node: {
-      versionCommand: "node --version",
-      parseVersion: (output: string) => output.replace(/^v/, ""),
-      missingMessage: "Node.js is not installed",
-    },
-  },
-  installs: {
-    docker: dockerInstallPlan,
-    git: gitInstallPlan,
-    node: nodeInstallPlan,
-    traefikDocker: traefikDockerPlan,
-    traefikBinary: traefikBinaryPlan,
-  },
-};