openship 0.1.0 → 0.1.1

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

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

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

@@ -0,0 +1,38 @@
+/**
+ * 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";