openship 0.2.3 → 0.4.0

package/dist/chunk-S6DSRLNE.js

@@ -0,0 +1,121 @@
+import {
+  LocalExecutor
+} from "./chunk-U2DPZSXA.js";
+import {
+  logEntry,
+  sq
+} from "./chunk-4CQWT2WL.js";
+
+// ../../packages/adapters/src/system/docker-edge-executor.ts
+import Dockerode from "dockerode";
+import { PassThrough } from "stream";
+var DEFAULT_SOCKET = "/var/run/docker.sock";
+var WRITE_CHUNK = 6e4;
+var DockerEdgeExecutor = class {
+  docker;
+  containerName;
+  fileMode;
+  /** node:fs backend — used only in "mounted" mode, where the routing volumes
+   *  really are in this process's filesystem. */
+  files = new LocalExecutor();
+  constructor(opts) {
+    this.containerName = opts.containerName;
+    this.docker = opts.docker ?? new Dockerode({ socketPath: opts.socketPath ?? DEFAULT_SOCKET });
+    this.fileMode = opts.fileMode ?? "mounted";
+  }
+  /** Run one command inside the edge container, capturing stdout/stderr + exit. */
+  async run(command) {
+    const container = this.docker.getContainer(this.containerName);
+    const exec = await container.exec({
+      Cmd: ["/bin/sh", "-c", command],
+      AttachStdout: true,
+      AttachStderr: true,
+      Tty: false
+    });
+    const stream = await exec.start({ stdin: false });
+    const outStream = new PassThrough();
+    const errStream = new PassThrough();
+    let stdout = "";
+    let stderr = "";
+    outStream.on("data", (c) => stdout += c.toString());
+    errStream.on("data", (c) => stderr += c.toString());
+    this.docker.modem.demuxStream(stream, outStream, errStream);
+    await new Promise((resolve, reject) => {
+      stream.on("end", () => resolve());
+      stream.on("error", reject);
+    });
+    outStream.end();
+    errStream.end();
+    let info = await exec.inspect();
+    for (let i = 0; info.Running && i < 50; i++) {
+      await new Promise((r) => setTimeout(r, 100));
+      info = await exec.inspect();
+    }
+    return { code: info.ExitCode ?? (info.Running ? 1 : 0), stdout, stderr };
+  }
+  async exec(command) {
+    const { code, stdout, stderr } = await this.run(command);
+    if (code !== 0) {
+      const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+      throw new Error(
+        detail || `command exited ${code} in edge container ${this.containerName}`
+      );
+    }
+    return stdout.trim();
+  }
+  async streamExec(command, onLog) {
+    const { code, stdout, stderr } = await this.run(command);
+    const output = [stdout, stderr].filter(Boolean).join("");
+    if (output) onLog(logEntry(output, code === 0 ? "info" : "error"));
+    return { code, output };
+  }
+  // ── File ops ─────────────────────────────────────────────────────────────
+  // "mounted": the shared volume is in this process's filesystem → node:fs.
+  // "container": reach it through the daemon → `docker exec` in the edge.
+  async writeFile(path, content) {
+    if (this.fileMode === "mounted") return this.files.writeFile(path, content);
+    const encoded = Buffer.from(content, "utf8").toString("base64");
+    const dir = path.replace(/\/[^/]*$/, "");
+    if (dir && dir !== path) await this.exec(`mkdir -p ${sq(dir)}`);
+    if (encoded.length === 0) {
+      await this.exec(`: > ${sq(path)}`);
+      return;
+    }
+    for (let offset = 0; offset < encoded.length; offset += WRITE_CHUNK) {
+      const chunk = encoded.slice(offset, offset + WRITE_CHUNK);
+      const redirect = offset === 0 ? ">" : ">>";
+      await this.exec(`printf '%s' ${sq(chunk)} | base64 -d ${redirect} ${sq(path)}`);
+    }
+  }
+  async readFile(path) {
+    if (this.fileMode === "mounted") return this.files.readFile(path);
+    return this.exec(`cat ${sq(path)}`);
+  }
+  async exists(path) {
+    if (this.fileMode === "mounted") return this.files.exists(path);
+    const { code } = await this.run(`test -e ${sq(path)}`);
+    return code === 0;
+  }
+  async mkdir(path) {
+    if (this.fileMode === "mounted") return this.files.mkdir(path);
+    await this.exec(`mkdir -p ${sq(path)}`);
+  }
+  async rm(path) {
+    if (this.fileMode === "mounted") return this.files.rm(path);
+    await this.exec(`rm -rf ${sq(path)}`);
+  }
+  transferIn(localPath, remotePath, onLog, options) {
+    if (this.fileMode === "container") {
+      return Promise.reject(
+        new Error("transferIn is not supported against a container-mode edge")
+      );
+    }
+    return this.files.transferIn(localPath, remotePath, onLog, options);
+  }
+  async dispose() {
+  }
+};
+
+export {
+  DockerEdgeExecutor
+};

package/dist/chunk-TEYJYSMT.js

@@ -0,0 +1,409 @@
+import {
+  COMPONENT_INSTALLERS,
+  checkAll,
+  checkComponents
+} from "./chunk-46YJFP4S.js";
+
+// ../../packages/adapters/src/system/state.ts
+var DEFAULT_STATE_PATH = "/etc/openship/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: ["openresty"], message: "Routing requires OpenResty" },
+      { feature: "ssl", requires: ["openresty", "certbot"], message: "SSL requires OpenResty and certbot" }
+    ];
+  }
+  return [
+    { feature: "build", requires: ["git"], message: "Build requires Git" },
+    { feature: "routing", requires: ["openresty"], message: "Routing requires OpenResty" },
+    { feature: "ssl", requires: ["openresty", "certbot"], message: "SSL requires OpenResty and certbot" }
+  ];
+}
+function resolveRequired(mode) {
+  return mode === "docker" ? ["docker", "git", "openresty", "certbot"] : ["git", "openresty", "certbot"];
+}
+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;
+  constructor(mode, opts) {
+    this.mode = mode;
+    this.executor = opts.executor;
+    this.rules = resolveRules(mode);
+    this.required = resolveRequired(mode);
+    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
+   *   - Cache is stale (> 24h since last verification)
+   *
+   * 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.verify().catch(() => {
+      });
+      return true;
+    }
+    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 state = await this.loadState();
+    if (state?.setupComplete) {
+      const allPresent = rule.requires.every(
+        (name) => state.components[name]?.healthy === true
+      );
+      if (allPresent) {
+        return { feature, ready: true, missing: [], message: `${feature} is ready` };
+      }
+    }
+    const statuses = await checkComponents(this.executor, rule.requires);
+    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;
+  }
+  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;
+    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 critical = async () => {
+      const statuses = await checkComponents(this.executor, names);
+      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, names);
+      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-U2DPZSXA.js

@@ -0,0 +1,112 @@
+import {
+  getLocalExecEnv,
+  getLocalShellArgs,
+  getLocalShellPath,
+  logEntry,
+  sq
+} from "./chunk-4CQWT2WL.js";
+
+// ../../packages/adapters/src/system/local-executor.ts
+import { exec, spawn } from "child_process";
+import {
+  access,
+  mkdir as fsMkdir,
+  readFile as fsReadFile,
+  rm as fsRm,
+  writeFile as fsWriteFile
+} from "fs/promises";
+import { dirname } from "path";
+var LocalExecutor = class {
+  async exec(command, opts) {
+    return new Promise((resolve, reject) => {
+      const shell = getLocalShellPath();
+      exec(
+        command,
+        {
+          timeout: opts?.timeout ?? 3e4,
+          shell,
+          env: getLocalExecEnv()
+        },
+        (err, stdout, stderr) => {
+          if (err) {
+            const detail = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+            reject(new Error(detail || err.message));
+          } else resolve(stdout.trim());
+        }
+      );
+    });
+  }
+  streamExec(command, onLog) {
+    return new Promise((resolve) => {
+      const child = spawn(getLocalShellPath(), getLocalShellArgs(command), {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: getLocalExecEnv()
+      });
+      const chunks = [];
+      const onChunk = (data, level) => {
+        const text = data.toString();
+        if (!text) return;
+        chunks.push(text);
+        onLog(logEntry(text, level, data.toString("base64")));
+      };
+      child.stdout.on("data", (data) => onChunk(data, "info"));
+      child.stderr.on("data", (data) => onChunk(data, "warn"));
+      child.on("close", (code) => {
+        resolve({ code: code ?? 1, output: chunks.join("") });
+      });
+      child.on("error", (err) => {
+        onLog(logEntry(`Process error: ${err.message}`, "error"));
+        resolve({ code: 1, output: err.message });
+      });
+    });
+  }
+  async writeFile(path, content) {
+    await fsMkdir(dirname(path), { recursive: true });
+    await fsWriteFile(path, content, "utf-8");
+  }
+  async readFile(path) {
+    return fsReadFile(path, "utf-8");
+  }
+  async exists(path) {
+    try {
+      await access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(path) {
+    await fsMkdir(path, { recursive: true });
+  }
+  async rm(path) {
+    try {
+      await fsRm(path, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  async transferIn(localPath, remotePath, onLog, options) {
+    const log = onLog ?? (() => {
+    });
+    if (options?.includes?.length) {
+      for (const p of options.includes) {
+        const { code: code2 } = await this.streamExec(
+          `cp -a ${sq(localPath + "/" + p)} ${sq(remotePath + "/" + p)}`,
+          log
+        );
+        if (code2 !== 0) throw new Error(`Failed to copy ${p}`);
+      }
+      return;
+    }
+    const { code } = await this.streamExec(
+      `cp -a ${sq(localPath + "/")}. ${sq(remotePath)}`,
+      log
+    );
+    if (code !== 0) throw new Error("Failed to copy local project files");
+  }
+  async dispose() {
+  }
+};
+
+export {
+  LocalExecutor
+};