@rakay-technology/kraft 0.7.4

package/dist/chunk-I2TOOF2A.js

@@ -0,0 +1,517 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+import {
+  COMPONENT_CHECKS,
+  COMPONENT_INSTALLERS,
+  checkAll,
+  checkComponents
+} from "./chunk-THTEUDBC.js";
+
+// ../../packages/adapters/src/system/requirements.ts
+var REMOTE_SERVER_REQUIRED_COMPONENTS = ["docker", "git"];
+var SYSTEM_COMPONENT_DEPENDENCIES = {
+  // The managed edge is always the kraft-edge container. There is no
+  // host-OpenResty fallback, so Docker must be ready before any edge image work.
+  edge: ["docker"]
+};
+function getSystemComponentDependencies(name) {
+  return SYSTEM_COMPONENT_DEPENDENCIES[name] ?? [];
+}
+function resolveSystemComponentInstallPlan(requested) {
+  const ordered = [];
+  const resolved = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (name) => {
+    if (resolved.has(name)) return;
+    if (visiting.has(name)) {
+      throw new Error(`Cyclic system component dependency involving "${name}"`);
+    }
+    visiting.add(name);
+    for (const dependency of getSystemComponentDependencies(name))
+      visit(dependency);
+    visiting.delete(name);
+    resolved.add(name);
+    ordered.push(name);
+  };
+  for (const name of requested) visit(name);
+  return ordered;
+}
+
+// ../../packages/adapters/src/system/state.ts
+var DEFAULT_STATE_PATH = "/etc/kraft/setup-state.json";
+var FileStateStore = class {
+  statePath;
+  executor;
+  constructor(executor, statePath) {
+    this.executor = executor;
+    this.statePath = statePath ?? DEFAULT_STATE_PATH;
+  }
+  async get() {
+    try {
+      const exists = await this.executor.exists(this.statePath);
+      if (!exists) return null;
+      const content = await this.executor.readFile(this.statePath);
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async set(state) {
+    const content = JSON.stringify(state, null, 2);
+    await this.executor.writeFile(this.statePath, content);
+  }
+  async clear() {
+    await this.executor.rm(this.statePath);
+  }
+};
+
+// ../../packages/adapters/src/system/setup.ts
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function resolveRules(mode) {
+  if (mode === "docker") {
+    return [
+      {
+        feature: "build",
+        requires: ["git", "docker"],
+        message: "Build requires Git and Docker"
+      },
+      {
+        feature: "deploy",
+        requires: ["docker"],
+        message: "Deploy requires Docker"
+      },
+      {
+        feature: "routing",
+        requires: ["edge"],
+        message: "Routing requires the edge"
+      },
+      { feature: "ssl", requires: ["edge"], message: "SSL requires the edge" }
+    ];
+  }
+  return [
+    { feature: "build", requires: ["git"], message: "Build requires Git" },
+    {
+      feature: "routing",
+      requires: ["edge"],
+      message: "Routing requires the edge"
+    },
+    { feature: "ssl", requires: ["edge"], message: "SSL requires the edge" }
+  ];
+}
+function resolveRequired() {
+  return resolveSystemComponentInstallPlan([
+    ...REMOTE_SERVER_REQUIRED_COMPONENTS,
+    "edge"
+  ]);
+}
+var SystemManager = class {
+  mode;
+  executor;
+  rules;
+  required;
+  stateStore;
+  installerConfig;
+  provisionLock;
+  assumeInstalled;
+  /** In-memory cache to avoid even reading from disk/DB on hot paths. */
+  cachedState = null;
+  /** In-flight background re-verification, if any (see kickBackgroundVerify). */
+  verifyInFlight = null;
+  constructor(mode, opts) {
+    this.mode = mode;
+    this.executor = opts.executor;
+    this.rules = resolveRules(mode);
+    this.required = resolveRequired();
+    this.stateStore = opts.stateStore ?? new FileStateStore(opts.executor);
+    this.installerConfig = opts.installerConfig ?? {};
+    this.provisionLock = opts.provisionLock;
+    this.assumeInstalled = opts.assumeInstalled ?? false;
+  }
+  // ── Fast-path state queries (cached) ─────────────────────────────────
+  /**
+   * Is the server fully set up? Reads from cache - never runs checks.
+   *
+   * Returns false if:
+   *   - No cached state (first boot)
+   *   - Cached state says setupComplete = false
+   *
+   * A stale cache (> 24h) still answers true, with a re-verification kicked behind
+   * the call — this must never block.
+   *
+   * Use this on hot paths (every request). It's essentially free.
+   */
+  async isReady() {
+    const state = await this.loadState();
+    if (!state?.setupComplete) return false;
+    if (this.isStale(state)) this.kickBackgroundVerify();
+    return true;
+  }
+  /**
+   * Get the cached setup state without running any checks.
+   * Returns null if no state has been stored yet.
+   */
+  async getState() {
+    return this.loadState();
+  }
+  // ── Status checks (run on demand) ────────────────────────────────────
+  /**
+   * Check all registered components - runs actual system commands.
+   * Updates the cached state with fresh results.
+   */
+  async checkAll() {
+    const components = await checkAll(this.executor);
+    const missing = components.filter((c) => this.required.includes(c.name) && !c.healthy).map((c) => c.name);
+    await this.updateStateFromChecks(components);
+    return { components, ready: missing.length === 0, missing };
+  }
+  /** Check only the components required for this runtime mode. */
+  async checkRequired() {
+    const components = await checkComponents(this.executor, this.required);
+    const missing = components.filter((c) => !c.healthy).map((c) => c.name);
+    await this.updateStateFromChecks(components);
+    return { components, ready: missing.length === 0, missing };
+  }
+  /**
+   * Check whether a specific feature is ready.
+   *
+   * Fast path: if cached state shows all prerequisites installed,
+   * returns immediately without running system commands.
+   */
+  async checkFeature(feature) {
+    if (this.assumeInstalled) {
+      return {
+        feature,
+        ready: true,
+        missing: [],
+        message: `${feature} assumed installed`
+      };
+    }
+    const rule = this.rules.find((r) => r.feature === feature);
+    if (!rule) {
+      return {
+        feature,
+        ready: true,
+        missing: [],
+        message: `No prerequisites for "${feature}"`
+      };
+    }
+    const required = resolveSystemComponentInstallPlan(rule.requires);
+    const state = await this.loadState();
+    if (state?.setupComplete) {
+      const allPresent = required.every(
+        (name) => state.components[name]?.healthy === true
+      );
+      if (allPresent) {
+        if (this.isStale(state)) this.kickBackgroundVerify();
+        return {
+          feature,
+          ready: true,
+          missing: [],
+          message: `${feature} is ready`
+        };
+      }
+    }
+    const statuses = await checkComponents(this.executor, required);
+    const unhealthy = statuses.filter((s) => !s.healthy);
+    return {
+      feature,
+      ready: unhealthy.length === 0,
+      missing: unhealthy,
+      message: unhealthy.length === 0 ? `${feature} is ready` : `${rule.message} - missing: ${unhealthy.map((s) => s.name).join(", ")}`
+    };
+  }
+  /**
+   * Require a feature to be ready, or throw.
+   *
+   * Fast path reads cached state. Use before operations:
+   *   await system.requireFeature("deploy");
+   */
+  async requireFeature(feature) {
+    const readiness = await this.checkFeature(feature);
+    if (!readiness.ready) {
+      throw new Error(readiness.message);
+    }
+  }
+  /**
+   * Ensure a feature is ready: check prerequisites, install missing ones, re-validate.
+   *
+   * This is the operational path used by deploy/build flows when they can safely
+   * self-heal missing system components instead of hard-failing immediately.
+   */
+  async ensureFeature(feature, onLog, config) {
+    if (this.assumeInstalled) return;
+    const logFn = onLog ?? (() => {
+    });
+    const installerConfig = config ?? this.installerConfig;
+    const readiness = await this.checkFeature(feature);
+    if (readiness.ready) return;
+    await this.ensureNamedComponents(
+      readiness.missing.map((component) => component.name),
+      logFn,
+      installerConfig,
+      `Checking required system components for ${feature}...`,
+      (names) => `${this.rules.find((rule) => rule.feature === feature)?.message ?? feature} - missing: ${names.join(", ")}`
+    );
+  }
+  async ensureComponents(names, onLog, config) {
+    if (this.assumeInstalled) return;
+    const logFn = onLog ?? (() => {
+    });
+    const installerConfig = config ?? this.installerConfig;
+    await this.ensureNamedComponents(
+      names,
+      logFn,
+      installerConfig,
+      "Checking required system components...",
+      (missingNames) => `Required components are still not ready: ${missingNames.join(", ")}`
+    );
+  }
+  // ── Installation ─────────────────────────────────────────────────────
+  /**
+   * Install a single component with streamed logs.
+   */
+  async installComponent(name, onLog) {
+    const logFn = onLog ?? (() => {
+    });
+    return this.runInstaller(name, logFn, this.installerConfig);
+  }
+  /**
+   * Full setup: check → install missing → validate → cache state.
+   *
+   * This is the main provisioning entrypoint called from the dashboard
+   * setup wizard. The InstallerConfig should be pre-collected from the
+   * user (ACME email, domain, etc.) before calling this.
+   */
+  async setup(onLog, config) {
+    const logFn = onLog ?? (() => {
+    });
+    const installerConfig = config ?? this.installerConfig;
+    logFn(info(`Starting ${this.mode} server setup...`));
+    logFn(info(`Required components: ${this.required.join(", ")}`));
+    logFn(info("Checking installed components..."));
+    const initial = await this.checkRequired();
+    const alreadyInstalled = initial.components.filter((c) => c.healthy).map((c) => c.name);
+    if (alreadyInstalled.length > 0) {
+      logFn(info(`Already installed: ${alreadyInstalled.join(", ")}`));
+    }
+    if (initial.ready) {
+      logFn(info("All components are already installed - nothing to do"));
+      await this.markSetupComplete();
+      return {
+        installed: [],
+        skipped: alreadyInstalled,
+        failed: [],
+        ready: true
+      };
+    }
+    logFn(info(`Missing: ${initial.missing.join(", ")}`));
+    const { installed, failed } = await this.installMany(
+      initial.missing,
+      logFn,
+      installerConfig,
+      false
+    );
+    logFn(info("\nValidating installation..."));
+    const final = await this.checkRequired();
+    if (final.ready) {
+      logFn(info("Server setup complete - all components healthy"));
+      await this.markSetupComplete();
+    } else {
+      logFn({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `Setup incomplete - still missing: ${final.missing.join(", ")}`,
+        level: "warn"
+      });
+    }
+    return {
+      installed,
+      skipped: alreadyInstalled,
+      failed,
+      ready: final.ready
+    };
+  }
+  // ── State management ─────────────────────────────────────────────────
+  /**
+   * Invalidate the cached state.
+   *
+   * Call this when an operation fails because a component is missing
+   * (e.g., Docker daemon went down). The next `isReady()` call will
+   * return false, and `requireFeature()` will re-check.
+   */
+  async invalidate() {
+    this.cachedState = null;
+    await this.stateStore.clear();
+  }
+  /**
+   * Force re-verification: run all checks and update state.
+   * Called automatically when cache is stale, or manually by the user.
+   */
+  async verify() {
+    const result = await this.checkAll();
+    return result;
+  }
+  // ── Utilities ────────────────────────────────────────────────────────
+  getRules() {
+    return [...this.rules];
+  }
+  getRequired() {
+    return [...this.required];
+  }
+  // ── Internal state helpers ───────────────────────────────────────────
+  async loadState() {
+    if (this.cachedState) return this.cachedState;
+    this.cachedState = await this.stateStore.get();
+    return this.cachedState;
+  }
+  /**
+   * Run the staleness re-verification behind the caller — one at a time.
+   *
+   * The dedup is the point: a single deploy gates several features in a row, and
+   * every request calls isReady(), so an un-guarded kick would stack one full
+   * checkAll per call — each fanning 4 concurrent probes onto the same ssh
+   * connection, against sshd's MaxSessions (see mapWithConcurrency in checks.ts).
+   */
+  kickBackgroundVerify() {
+    if (this.verifyInFlight) return;
+    this.verifyInFlight = this.verify().catch(() => {
+    }).finally(() => {
+      this.verifyInFlight = null;
+    });
+  }
+  isStale(state) {
+    if (!state.lastVerifiedAt) return true;
+    const age = Date.now() - new Date(state.lastVerifiedAt).getTime();
+    return age > CACHE_TTL_MS;
+  }
+  async updateStateFromChecks(components) {
+    const existing = await this.loadState() ?? this.emptyState();
+    for (const c of components) {
+      existing.components[c.name] = {
+        installed: c.installed,
+        version: c.version,
+        running: c.running,
+        healthy: c.healthy,
+        installedAt: existing.components[c.name]?.installedAt
+      };
+    }
+    const allRequired = this.required.every(
+      (name) => existing.components[name]?.installed
+    );
+    existing.setupComplete = allRequired;
+    const checked = new Set(components.map((c) => c.name));
+    const coveredAll = this.required.every(
+      (name) => checked.has(name) || !COMPONENT_CHECKS[name]
+    );
+    if (coveredAll) {
+      existing.lastVerifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.cachedState = existing;
+    await this.stateStore.set(existing);
+  }
+  async markComponentInstalled(name, version) {
+    const state = await this.loadState() ?? this.emptyState();
+    state.components[name] = {
+      installed: true,
+      version,
+      healthy: false,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.cachedState = state;
+    await this.stateStore.set(state);
+  }
+  async markSetupComplete() {
+    const state = await this.loadState() ?? this.emptyState();
+    state.setupComplete = true;
+    state.lastVerifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.cachedState = state;
+    await this.stateStore.set(state);
+  }
+  emptyState() {
+    return {
+      setupComplete: false,
+      mode: this.mode,
+      components: {},
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async runInstaller(name, logFn, installerConfig) {
+    const installer = COMPONENT_INSTALLERS[name];
+    if (!installer) {
+      logFn(info(`No installer available for "${name}"`));
+      return {
+        component: name,
+        success: false,
+        error: `No installer for "${name}"`
+      };
+    }
+    const result = await installer(this.executor, logFn, installerConfig);
+    if (result.success) {
+      await this.markComponentInstalled(name, result.version);
+    }
+    return result;
+  }
+  async installMany(names, logFn, installerConfig, stopOnFailure) {
+    const installed = [];
+    const failed = [];
+    for (const name of names) {
+      logFn(info(`
+\u2500\u2500 Installing ${name} ${"\u2500".repeat(50)}`));
+      const result = await this.runInstaller(name, logFn, installerConfig);
+      if (result.success) {
+        installed.push(result);
+        continue;
+      }
+      failed.push(result);
+      logFn(info(`Failed to install ${name}: ${result.error}`));
+      if (stopOnFailure) break;
+    }
+    return { installed, failed };
+  }
+  async ensureNamedComponents(names, logFn, installerConfig, heading, errorMessage) {
+    const required = resolveSystemComponentInstallPlan(names);
+    const critical = async () => {
+      const statuses = await checkComponents(this.executor, required);
+      const missing = statuses.filter((status) => !status.healthy);
+      if (missing.length === 0) {
+        await this.updateStateFromChecks(statuses);
+        return;
+      }
+      logFn(info(heading));
+      logFn(
+        info(
+          `Missing: ${missing.map((component) => component.name).join(", ")}`
+        )
+      );
+      const { failed } = await this.installMany(
+        missing.map((component) => component.name),
+        logFn,
+        installerConfig,
+        true
+      );
+      if (failed.length > 0) {
+        throw new Error(
+          failed[0].error ?? `Failed to install ${failed[0].component}`
+        );
+      }
+      const recheck = await checkComponents(this.executor, required);
+      await this.updateStateFromChecks(recheck);
+      const unhealthy = recheck.filter((status) => !status.healthy);
+      if (unhealthy.length > 0) {
+        throw new Error(errorMessage(unhealthy.map((status) => status.name)));
+      }
+    };
+    return this.provisionLock ? this.provisionLock.run(critical) : critical();
+  }
+};
+function info(message) {
+  return { timestamp: (/* @__PURE__ */ new Date()).toISOString(), message, level: "info" };
+}
+
+export {
+  SystemManager
+};

package/dist/chunk-I3DPMTSF.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env sh
+":" //# ; exec "$(command -v node || command -v bun)" "$0" "$@"
+import { createRequire as __ospCreateRequire } from "node:module";
+const require = __ospCreateRequire(import.meta.url);
+
+// ../../packages/adapters/src/system/edge-exec-error.ts
+var EDGE_DOWN_MARKER = "the edge container is not running";
+function isEdgeDownFailure(text) {
+  return /is restarting, wait until the container is running/i.test(text) || /container .* is not running/i.test(text) || /\bis not running\b/i.test(text) || /No such container/i.test(text) || /container .* is paused/i.test(text) || /invalid PID number/i.test(text);
+}
+function explainEdgeDown(opts) {
+  const { container, status, reason } = opts;
+  const state = status?.trim() ? ` (${status.trim()})` : "";
+  const crashLooping = status?.trim() === "restarting";
+  const consequence = crashLooping ? `it is crash-looping, so nothing that runs through the edge on this server can work \u2014 certificate issuance, config reloads and route changes all go through it` : `nothing that runs through the edge on this server can work until it is up \u2014 certificate issuance, config reloads and route changes all go through it`;
+  const cause = reason?.trim() ? `OpenResty is refusing to start: ${reason.trim().replace(/\s+/g, " ")}. Fix that, then \`docker start ${container}\` and retry.` : `Run \`docker logs --tail 40 ${container}\` on the server for the reason, then retry.`;
+  return `${EDGE_DOWN_MARKER} ("${container}")${state} \u2014 ${consequence}. ${cause}`;
+}
+function edgeDownExplanation(text) {
+  if (!text) return null;
+  const line = text.split("\n").map((l) => l.trim()).find((l) => l.includes(EDGE_DOWN_MARKER));
+  return line || null;
+}
+
+export {
+  isEdgeDownFailure,
+  explainEdgeDown,
+  edgeDownExplanation
+};