openship 0.1.1 → 0.1.7

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

@@ -1,439 +0,0 @@
-/**
- * Toolchain catalog — check recipes + install plan factories.
- *
- * Same pattern as system/catalog.ts:
- *   - `checks` → recipes for detecting tools (versionCommand, parseVersion)
- *   - `installs` → factory functions that return install plans per-OS
- *
- * OS-awareness lives in the install plan factories via EnvironmentProfile.
- * The catalog itself is universal.
- */
-
-import type { EnvironmentProfile } from "../system/environment";
-import type { ToolchainCheckEntry, ToolchainInstallPlan } from "./types";
-
-// ─── Install plan factories ─────────────────────────────────────────────────
-
-function nodeInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  if (profile.os === "linux" && ["apt", "dnf", "yum"].includes(profile.packageManager)) {
-    const installCommands: Record<string, string> = {
-      apt: "curl -fsSL https://deb.nodesource.com/setup_lts.x | bash - && apt-get install -y nodejs",
-      dnf: "curl -fsSL https://rpm.nodesource.com/setup_lts.x | bash - && dnf install -y nodejs",
-      yum: "curl -fsSL https://rpm.nodesource.com/setup_lts.x | bash - && yum install -y nodejs",
-    };
-    return {
-      supported: true,
-      installCommand: installCommands[profile.packageManager],
-      verifyCommand: "node --version",
-    };
-  }
-
-  const fallbacks: Record<string, string> = {
-    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 goInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  if (profile.os === "linux") {
-    const arch = profile.arch === "arm64" ? "arm64" : "amd64";
-    return {
-      supported: true,
-      installCommand: [
-        `curl -fsSL https://go.dev/dl/go1.22.5.linux-${arch}.tar.gz -o /tmp/go.tar.gz`,
-        "rm -rf /usr/local/go",
-        "tar -C /usr/local -xzf /tmp/go.tar.gz",
-        "rm /tmp/go.tar.gz",
-        'echo \'export PATH=$PATH:/usr/local/go/bin\' >> /etc/profile.d/go.sh',
-        "export PATH=$PATH:/usr/local/go/bin",
-      ].join(" && "),
-      verifyCommand: "/usr/local/go/bin/go version || go version",
-    };
-  }
-
-  if (profile.packageManager === "brew") {
-    return {
-      supported: true,
-      installCommand: "brew install go",
-      verifyCommand: "go version",
-    };
-  }
-
-  return {
-    supported: false,
-    unsupportedReason: "Go installation is only supported on Linux and macOS (brew)",
-  };
-}
-
-function rustInstallPlan(_profile: EnvironmentProfile): ToolchainInstallPlan {
-  return {
-    supported: true,
-    installCommand:
-      "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && . $HOME/.cargo/env",
-    verifyCommand: ". $HOME/.cargo/env && rustc --version",
-  };
-}
-
-function pythonInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  const commands: Record<string, string> = {
-    apt: "apt-get update -qq && apt-get install -y -qq python3 python3-pip python3-venv",
-    dnf: "dnf install -y python3 python3-pip",
-    yum: "yum install -y python3 python3-pip",
-    brew: "brew install python3",
-  };
-
-  const installCommand = commands[profile.packageManager];
-  if (!installCommand) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for Python installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand,
-    verifyCommand: "python3 --version",
-  };
-}
-
-function rubyInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  const commands: Record<string, string> = {
-    apt: "apt-get update -qq && apt-get install -y -qq ruby-full build-essential",
-    dnf: "dnf install -y ruby ruby-devel",
-    yum: "yum install -y ruby ruby-devel",
-    brew: "brew install ruby",
-  };
-
-  const installCommand = commands[profile.packageManager];
-  if (!installCommand) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for Ruby installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand,
-    verifyCommand: "ruby --version",
-  };
-}
-
-function phpInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  if (profile.packageManager === "apt") {
-    return {
-      supported: true,
-      installCommand: [
-        "apt-get update -qq",
-        "apt-get install -y -qq php-cli php-mbstring php-xml php-curl unzip",
-        "curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer",
-      ].join(" && "),
-      verifyCommand: "php --version && composer --version",
-    };
-  }
-
-  const commands: Record<string, string> = {
-    dnf: "dnf install -y php-cli php-mbstring php-xml php-curl composer",
-    yum: "yum install -y php-cli php-mbstring php-xml php-curl",
-    brew: "brew install php composer",
-  };
-
-  const installCommand = commands[profile.packageManager];
-  if (!installCommand) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for PHP installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand,
-    verifyCommand: "php --version",
-  };
-}
-
-function javaInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  const commands: Record<string, string> = {
-    apt: "apt-get update -qq && apt-get install -y -qq openjdk-21-jdk",
-    dnf: "dnf install -y java-21-openjdk-devel",
-    yum: "yum install -y java-21-openjdk-devel",
-    brew: "brew install openjdk@21",
-  };
-
-  const installCommand = commands[profile.packageManager];
-  if (!installCommand) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for Java installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand,
-    verifyCommand: "java --version 2>&1",
-  };
-}
-
-function dotnetInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  if (profile.os === "linux") {
-    return {
-      supported: true,
-      installCommand:
-        "curl -fsSL https://dot.net/v1/dotnet-install.sh | bash -s -- --channel 8.0 --install-dir /usr/local/share/dotnet && ln -sf /usr/local/share/dotnet/dotnet /usr/local/bin/dotnet",
-      verifyCommand: "dotnet --version",
-    };
-  }
-
-  if (profile.packageManager === "brew") {
-    return {
-      supported: true,
-      installCommand: "brew install dotnet-sdk",
-      verifyCommand: "dotnet --version",
-    };
-  }
-
-  return {
-    supported: false,
-    unsupportedReason: ".NET SDK installation is only supported on Linux and macOS (brew)",
-  };
-}
-
-function elixirInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  const commands: Record<string, string> = {
-    apt: "apt-get update -qq && apt-get install -y -qq erlang elixir",
-    dnf: "dnf install -y erlang elixir",
-    brew: "brew install elixir",
-  };
-
-  const installCommand = commands[profile.packageManager];
-  if (!installCommand) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for Elixir installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand,
-    verifyCommand: "elixir --version",
-  };
-}
-
-function bundlerInstallPlan(_profile: EnvironmentProfile): ToolchainInstallPlan {
-  return {
-    supported: true,
-    installCommand: "gem install bundler",
-    verifyCommand: "bundler --version",
-  };
-}
-
-function composerInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  if (profile.packageManager === "brew") {
-    return {
-      supported: true,
-      installCommand: "brew install composer",
-      verifyCommand: "composer --version",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand:
-      "curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer",
-    verifyCommand: "composer --version",
-  };
-}
-
-function pipInstallPlan(profile: EnvironmentProfile): ToolchainInstallPlan {
-  const commands: Record<string, string> = {
-    apt: "apt-get update -qq && apt-get install -y -qq python3-pip",
-    dnf: "dnf install -y python3-pip",
-    yum: "yum install -y python3-pip",
-    brew: "python3 -m ensurepip --upgrade",
-  };
-
-  const installCommand = commands[profile.packageManager];
-  if (!installCommand) {
-    return {
-      supported: false,
-      unsupportedReason: "No supported package manager found for pip installation",
-    };
-  }
-
-  return {
-    supported: true,
-    installCommand,
-    verifyCommand: "pip3 --version || pip --version",
-  };
-}
-
-// ─── The catalog ─────────────────────────────────────────────────────────────
-
-type InstallPlanFactory = (profile: EnvironmentProfile) => ToolchainInstallPlan;
-
-export const toolchainCatalog = {
-  /**
-   * Check recipes — how to detect each tool and parse its version.
-   *
-   * Every tool in LANGUAGES[lang].requiredTools must have an entry here.
-   */
-  checks: {
-    node: {
-      label: "Node.js",
-      versionCommand: "node --version",
-      parseVersion: (output: string) => output.replace(/^v/, "").trim(),
-      missingMessage: "Node.js is not installed",
-      installable: true,
-    },
-    npm: {
-      label: "npm",
-      versionCommand: "npm --version",
-      parseVersion: (output: string) => output.trim(),
-      missingMessage: "npm is not installed",
-      installable: false,
-      providedBy: "node",
-    },
-    go: {
-      label: "Go",
-      versionCommand: "go version",
-      parseVersion: (output: string) => output.match(/go(\d+\.\d+(\.\d+)?)/)?.[1] ?? output.trim(),
-      missingMessage: "Go is not installed",
-      installable: true,
-    },
-    rustc: {
-      label: "Rust compiler",
-      versionCommand: "rustc --version",
-      parseVersion: (output: string) => output.match(/rustc (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "Rust compiler is not installed",
-      installable: true,
-    },
-    cargo: {
-      label: "Cargo",
-      versionCommand: "cargo --version",
-      parseVersion: (output: string) => output.match(/cargo (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "Cargo is not installed",
-      installable: false,
-      providedBy: "rustc",
-    },
-    python3: {
-      label: "Python 3",
-      versionCommand: "python3 --version",
-      parseVersion: (output: string) => output.match(/Python (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "Python 3 is not installed",
-      installable: true,
-    },
-    pip: {
-      label: "pip",
-      versionCommand: "pip3 --version || pip --version",
-      parseVersion: (output: string) => output.match(/pip (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "pip is not installed",
-      installable: true,
-      providedBy: "python3",
-    },
-    ruby: {
-      label: "Ruby",
-      versionCommand: "ruby --version",
-      parseVersion: (output: string) => output.match(/ruby (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "Ruby is not installed",
-      installable: true,
-    },
-    bundler: {
-      label: "Bundler",
-      versionCommand: "bundler --version",
-      parseVersion: (output: string) => output.match(/(\d+\.\d+\.\d+)/)?.[1] ?? output.trim(),
-      missingMessage: "Bundler is not installed",
-      installable: true,
-      providedBy: "ruby",
-    },
-    php: {
-      label: "PHP",
-      versionCommand: "php --version",
-      parseVersion: (output: string) => output.match(/PHP (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "PHP is not installed",
-      installable: true,
-    },
-    composer: {
-      label: "Composer",
-      versionCommand: "composer --version",
-      parseVersion: (output: string) => output.match(/(\d+\.\d+\.\d+)/)?.[1] ?? output.trim(),
-      missingMessage: "Composer is not installed",
-      installable: true,
-      providedBy: "php",
-    },
-    java: {
-      label: "Java",
-      versionCommand: "java --version 2>&1 || java -version 2>&1",
-      parseVersion: (output: string) => output.match(/(\d+\.\d+)/)?.[1] ?? output.trim(),
-      missingMessage: "Java is not installed",
-      installable: true,
-    },
-    javac: {
-      label: "Java compiler",
-      versionCommand: "javac --version 2>&1 || javac -version 2>&1",
-      parseVersion: (output: string) => output.match(/javac (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "Java compiler (javac) is not installed",
-      installable: false,
-      providedBy: "java",
-    },
-    dotnet: {
-      label: ".NET SDK",
-      versionCommand: "dotnet --version",
-      parseVersion: (output: string) => output.trim(),
-      missingMessage: ".NET SDK is not installed",
-      installable: true,
-    },
-    elixir: {
-      label: "Elixir",
-      versionCommand: "elixir --version 2>&1",
-      parseVersion: (output: string) => output.match(/Elixir (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "Elixir is not installed",
-      installable: true,
-    },
-    mix: {
-      label: "Mix",
-      versionCommand: "mix --version 2>&1",
-      parseVersion: (output: string) => output.match(/Mix (\S+)/)?.[1] ?? output.trim(),
-      missingMessage: "Mix is not installed",
-      installable: false,
-      providedBy: "elixir",
-    },
-  } as Record<string, ToolchainCheckEntry>,
-
-  /**
-   * Install plan factories — how to install each tool on a given OS.
-   *
-   * Only tools with `installable: true` (and no `providedBy`) need an entry.
-   * Tools like npm, cargo, mix are installed as part of their parent.
-   */
-  installs: {
-    node: nodeInstallPlan,
-    go: goInstallPlan,
-    rustc: rustInstallPlan,
-    python3: pythonInstallPlan,
-    pip: pipInstallPlan,
-    ruby: rubyInstallPlan,
-    bundler: bundlerInstallPlan,
-    php: phpInstallPlan,
-    composer: composerInstallPlan,
-    java: javaInstallPlan,
-    dotnet: dotnetInstallPlan,
-    elixir: elixirInstallPlan,
-  } as Record<string, InstallPlanFactory>,
-};

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

@@ -1,181 +0,0 @@
-/**
- * Toolchain health checks — detect installed language runtimes.
- *
- * Same pattern as system/checks.ts but for language-specific tools.
- * All checks run through CommandExecutor — works local + SSH.
- * Checks are fast, non-destructive, and run in parallel.
- */
-
-import { LANGUAGES, STACKS, type Language, type StackDefinition, type StackId } from "@repo/core";
-import type { CommandExecutor } from "../types";
-import type { ToolchainStatus, ToolchainCheckResult } from "./types";
-import { toolchainCatalog } from "./catalog";
-import { formatDuration, systemDebug } from "../system/debug";
-import { isRemoteConnectionError } from "../system/errors";
-
-function parseVersionParts(version: string): number[] {
-  const match = version.match(/\d+(?:\.\d+)*/)?.[0] ?? "0";
-  return match.split(".").map((part) => parseInt(part, 10) || 0);
-}
-
-function compareVersions(actual: string, minimum: string): number {
-  const actualParts = parseVersionParts(actual);
-  const minimumParts = parseVersionParts(minimum);
-  const maxLength = Math.max(actualParts.length, minimumParts.length);
-
-  for (let index = 0; index < maxLength; index += 1) {
-    const left = actualParts[index] ?? 0;
-    const right = minimumParts[index] ?? 0;
-    if (left > right) return 1;
-    if (left < right) return -1;
-  }
-
-  return 0;
-}
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-/** Run a command via executor, return stdout or null on failure. */
-async function tryExec(
-  executor: CommandExecutor,
-  command: string,
-): Promise<string | null> {
-  const startedAt = Date.now();
-  systemDebug("toolchain", `exec:start ${command}`);
-  try {
-    const result = await executor.exec(command, { timeout: 10_000 });
-    systemDebug(
-      "toolchain",
-      `exec:ok ${command} (${formatDuration(startedAt)})`,
-    );
-    return result;
-  } catch (err) {
-    if (isRemoteConnectionError(err)) {
-      systemDebug(
-        "toolchain",
-        `exec:abort ${command} (${formatDuration(startedAt)}) ${err instanceof Error ? err.message : String(err)}`,
-      );
-      throw err;
-    }
-    const msg = err instanceof Error ? err.message : String(err);
-    systemDebug(
-      "toolchain",
-      `exec:fail ${command} (${formatDuration(startedAt)}) ${msg}`,
-    );
-    return null;
-  }
-}
-
-// ─── Single tool check ──────────────────────────────────────────────────────
-
-/** Check a single tool — returns its status. */
-export async function checkTool(
-  executor: CommandExecutor,
-  name: string,
-  opts?: { minVersion?: string },
-): Promise<ToolchainStatus> {
-  const recipe = toolchainCatalog.checks[name];
-  if (!recipe) {
-    return {
-      name,
-      label: name,
-      installed: false,
-      healthy: false,
-      message: `Unknown tool: ${name}`,
-    };
-  }
-
-  const output = await tryExec(executor, recipe.versionCommand);
-  if (!output) {
-    systemDebug("toolchain", `${name}:missing`);
-    return {
-      name,
-      label: recipe.label,
-      installed: false,
-      healthy: false,
-      message: recipe.missingMessage,
-    };
-  }
-
-  const version = recipe.parseVersion(output);
-
-  if (opts?.minVersion && compareVersions(version, opts.minVersion) < 0) {
-    systemDebug("toolchain", `${name}:outdated v${version} < ${opts.minVersion}`);
-    return {
-      name,
-      label: recipe.label,
-      installed: true,
-      version,
-      requiredVersion: opts.minVersion,
-      healthy: false,
-      message: `${recipe.label} ${version} is installed but ${opts.minVersion}+ is required`,
-    };
-  }
-
-  systemDebug("toolchain", `${name}:healthy v${version}`);
-  return {
-    name,
-    label: recipe.label,
-    installed: true,
-    version,
-    requiredVersion: opts?.minVersion,
-    healthy: true,
-    message: `${recipe.label} ${version}`,
-  };
-}
-
-// ─── Batch checks ───────────────────────────────────────────────────────────
-
-/** Check a specific list of tools in parallel. */
-export async function checkTools(
-  executor: CommandExecutor,
-  toolNames: readonly string[],
-  requiredVersions?: Readonly<Record<string, string>>,
-): Promise<ToolchainCheckResult> {
-  const startedAt = Date.now();
-  systemDebug("toolchain", `checkTools:start [${toolNames.join(", ")}]`);
-
-  const tools = await Promise.all(
-    toolNames.map((name) =>
-      checkTool(executor, name, { minVersion: requiredVersions?.[name] }),
-    ),
-  );
-
-  const missing = tools.filter((t) => !t.installed).map((t) => t.name);
-  const outdated = tools.filter((t) => t.installed && !t.healthy).map((t) => t.name);
-  const ready = missing.length === 0 && outdated.length === 0;
-
-  systemDebug(
-    "toolchain",
-    `checkTools:done (${formatDuration(startedAt)}) ready=${ready} missing=[${missing.join(", ")}] outdated=[${outdated.join(", ")}]`,
-  );
-
-  return { tools, ready, missing, outdated };
-}
-
-/** Resolve required tools from a language, then check them all. */
-export async function checkToolchain(
-  executor: CommandExecutor,
-  language: Language,
-  requiredVersions?: Readonly<Record<string, string>>,
-): Promise<ToolchainCheckResult> {
-  const lang = LANGUAGES[language];
-  if (!lang || lang.requiredTools.length === 0) {
-    return { tools: [], ready: true, missing: [], outdated: [] };
-  }
-
-  return checkTools(executor, lang.requiredTools, requiredVersions);
-}
-
-/** Resolve required tools from a stack ID, then check them all. */
-export async function checkToolchainForStack(
-  executor: CommandExecutor,
-  stackId: string,
-): Promise<ToolchainCheckResult> {
-  const stack = STACKS[stackId as StackId] as StackDefinition | undefined;
-  if (!stack) {
-    return { tools: [], ready: true, missing: [], outdated: [] };
-  }
-
-  return checkToolchain(executor, stack.language, stack.requiredToolVersions);
-}

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

@@ -1,38 +0,0 @@
-/**
- * Toolchain layer barrel exports.
- *
- * Stack-level tool validation and installation for bare-metal builds.
- * Ensures language runtimes (Node, Go, Rust, Python, etc.) are present
- * before a build starts.
- *
- * Usage:
- *   import { checkToolchainForStack, installTools } from "./toolchain";
- *
- *   const result = await checkToolchainForStack(executor, "nextjs");
- *   if (!result.ready) {
- *     await installTools(executor, result.missing, onLog);
- *   }
- */
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-export type {
-  ToolchainStatus,
-  ToolchainCheckResult,
-  ToolchainCheckEntry,
-  ToolchainInstallPlan,
-  ToolchainInstallResult,
-} from "./types";
-
-// ─── Catalog ─────────────────────────────────────────────────────────────────
-export { toolchainCatalog } from "./catalog";
-
-// ─── Checks ──────────────────────────────────────────────────────────────────
-export {
-  checkTool,
-  checkTools,
-  checkToolchain,
-  checkToolchainForStack,
-} from "./checks";
-
-// ─── Installers ──────────────────────────────────────────────────────────────
-export { installTool, installTools } from "./installer";