openship 0.2.3 → 0.4.0

package/dist/chunk-Y37KHU7L.js

@@ -0,0 +1,31 @@
+// ../../packages/adapters/src/infra/cloud.ts
+var CloudInfraProvider = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  // ── Routing ──────────────────────────────────────────────────────────
+  async registerRoute(route) {
+    void route;
+  }
+  async removeRoute(domain) {
+    void domain;
+  }
+  // ── SSL ──────────────────────────────────────────────────────────────
+  async provisionCert(domain) {
+    return { domain, expiresAt: "", issuer: "oblien", verified: false };
+  }
+  async renewCert(domain) {
+    return { domain, expiresAt: "", issuer: "oblien", verified: false };
+  }
+  async verifyCert(domain) {
+    return { domain, expiresAt: "", issuer: "oblien", verified: false };
+  }
+  async installCert(_domain, _cert) {
+    throw new Error("Manual certificates are not supported on Openship Cloud");
+  }
+};
+
+export {
+  CloudInfraProvider
+};

package/dist/chunk-YL67EWYZ.js

@@ -0,0 +1,416 @@
+import {
+  getTarCreateEnv,
+  prepareSourceTarArgs
+} from "./chunk-4MG3BVHE.js";
+import {
+  TRANSFER_EXCLUDES,
+  packageManagerEnsureCommand,
+  safeErrorMessage
+} from "./chunk-JZLNHGLW.js";
+
+// ../../packages/adapters/src/runtime/git-clone.ts
+function sq(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function injectGitToken(repoUrl, token) {
+  if (!token) return repoUrl;
+  try {
+    const url = new URL(repoUrl);
+    if (url.protocol !== "https:") return repoUrl;
+    url.username = "x-access-token";
+    url.password = token;
+    return url.toString();
+  } catch {
+    return repoUrl;
+  }
+}
+function toGitHubSshUrl(repoUrl) {
+  try {
+    const url = new URL(repoUrl);
+    const host = url.hostname;
+    const repoPath = url.pathname.replace(/^\/+/, "").replace(/\.git$/, "");
+    return `git@${host}:${repoPath}.git`;
+  } catch {
+    return repoUrl;
+  }
+}
+var TERMINAL_PROMPT = ["GIT_TERMINAL_PROMPT", "0", false];
+function invocation(cloneUrl, entries, disableHelper) {
+  return {
+    cloneUrl,
+    gitEnv: entries.map(([k, v, q]) => `${k}=${q ? sq(v) : v}`).join(" "),
+    credFlag: disableHelper ? "-c credential.helper=" : "",
+    env: Object.fromEntries(entries.map(([k, v]) => [k, v])),
+    credArgs: disableHelper ? ["-c", "credential.helper="] : []
+  };
+}
+function assertNotOptionLike(repoUrl) {
+  if (repoUrl.trimStart().startsWith("-")) {
+    throw new Error(
+      `Refusing to clone from ${JSON.stringify(repoUrl)}: a repository URL must not start with "-" (git would read it as an option).`
+    );
+  }
+}
+function assembleGitClone(auth) {
+  assertNotOptionLike(auth.repoUrl);
+  if (auth.ssh) {
+    const sshCmd = `ssh -i ${sq(auth.ssh.keyFile)} -o IdentitiesOnly=yes -o StrictHostKeyChecking=yes -o UserKnownHostsFile=${sq(auth.ssh.knownHostsFile)}`;
+    return invocation(
+      toGitHubSshUrl(auth.repoUrl),
+      [TERMINAL_PROMPT, ["GIT_SSH_COMMAND", sshCmd, true]],
+      false
+    );
+  }
+  if (auth.gitCredentialHelperPath) {
+    return invocation(
+      auth.repoUrl,
+      [
+        TERMINAL_PROMPT,
+        ["GIT_CONFIG_COUNT", "2", false],
+        ["GIT_CONFIG_KEY_0", "credential.helper", false],
+        ["GIT_CONFIG_VALUE_0", auth.gitCredentialHelperPath, true],
+        ["GIT_CONFIG_KEY_1", "credential.useHttpPath", false],
+        ["GIT_CONFIG_VALUE_1", "true", false]
+      ],
+      false
+    );
+  }
+  if (auth.ambient) {
+    if (auth.ambient.via === "ssh") {
+      return invocation(toGitHubSshUrl(auth.repoUrl), [TERMINAL_PROMPT], false);
+    }
+    if (auth.ambient.via === "gh") {
+      return invocation(
+        auth.repoUrl,
+        [
+          TERMINAL_PROMPT,
+          ["GIT_CONFIG_COUNT", "1", false],
+          ["GIT_CONFIG_KEY_0", "credential.helper", false],
+          ["GIT_CONFIG_VALUE_0", "!gh auth git-credential", true]
+        ],
+        false
+      );
+    }
+    return invocation(auth.repoUrl, [TERMINAL_PROMPT], false);
+  }
+  return invocation(
+    injectGitToken(auth.repoUrl, auth.gitToken),
+    [TERMINAL_PROMPT, ["GIT_ASKPASS", "/bin/echo", false]],
+    true
+  );
+}
+
+// ../../packages/adapters/src/runtime/git-ssh-material.ts
+import { mkdir, rm, writeFile } from "fs/promises";
+async function materializeGitSsh(writer, dir, gitSsh) {
+  const keyFile = `${dir}/id`;
+  const knownHostsFile = `${dir}/known_hosts`;
+  await writer.ensureDir(dir);
+  try {
+    await writer.writeSecret(keyFile, gitSsh.privateKey);
+    await writer.writeSecret(knownHostsFile, gitSsh.knownHosts);
+  } catch (err) {
+    await writer.remove(dir);
+    throw err;
+  }
+  return {
+    keyFile,
+    knownHostsFile,
+    cleanup: () => writer.remove(dir)
+  };
+}
+function shellGitSshWriter(io) {
+  return {
+    ensureDir: async (dir) => {
+      await io.exec(`mkdir -p ${sq(dir)} && chmod 700 ${sq(dir)}`);
+    },
+    writeSecret: async (path, content) => {
+      await io.writeSecret(path, content);
+      await io.exec(`chmod 600 ${sq(path)}`);
+    },
+    remove: async (dir) => {
+      await io.exec(`rm -rf ${sq(dir)}`).catch(() => {
+      });
+    }
+  };
+}
+function localGitSshWriter() {
+  return {
+    ensureDir: (dir) => mkdir(dir, { recursive: true, mode: 448 }).then(() => {
+    }),
+    writeSecret: (path, content) => writeFile(path, content, { mode: 384 }),
+    remove: (dir) => rm(dir, { recursive: true, force: true }).catch(() => {
+    })
+  };
+}
+
+// ../../packages/adapters/src/runtime/build-pipeline.ts
+var BuildLogger = class {
+  constructor(onLog) {
+    this.onLog = onLog;
+  }
+  /** Emit a plain log line. */
+  log(message, level = "info", meta) {
+    this.onLog?.({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), message, level, ...meta });
+  }
+  /** Emit a step lifecycle event (running / completed / failed / skipped). */
+  step(step, status, message) {
+    this.onLog?.({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message,
+      level: status === "failed" ? "error" : "info",
+      step,
+      stepStatus: status
+    });
+  }
+  /**
+   * Run a step: emit running → execute → emit completed/failed.
+   * Throws on failure so the caller can handle it.
+   */
+  async runStep(step, label, fn) {
+    this.step(step, "running", label);
+    try {
+      await fn();
+      this.step(step, "completed", `${label} - done`);
+    } catch (err) {
+      const msg = safeErrorMessage(err);
+      this.step(step, "failed", `${label} - ${msg}`);
+      throw err;
+    }
+  }
+  /** Get the underlying callback for passing to exec / stream functions. */
+  get callback() {
+    return (entry) => this.onLog?.(entry);
+  }
+};
+var BuildCancelledError = class extends Error {
+  constructor(message = "Build cancelled") {
+    super(message);
+    this.name = "BuildCancelledError";
+  }
+};
+async function runBuildPipeline(env, config, logger) {
+  let startTime = Date.now();
+  let currentStep = "prepare";
+  const exec = (command) => env.exec(command, logger.callback);
+  const buildDir = resolveBuildDirectory(env.projectDir, config.rootDirectory);
+  if (env.hasNativeEnv) {
+    const { cpuCores, memoryMb, diskMb } = config.resources;
+    logger.log(`Machine: ${cpuCores} CPU \xB7 ${memoryMb} MB RAM \xB7 ${diskMb} MB Disk`);
+  }
+  try {
+    if (env.preflight) {
+      await logger.runStep("prepare", "Preparing server", async () => {
+        await env.preflight(config, logger);
+      });
+    }
+    startTime = Date.now();
+    currentStep = "clone";
+    if (config.localPath || config.sourceStaged) {
+      logger.step("clone", "completed", "Source ready");
+    } else {
+      await logger.runStep(
+        "clone",
+        `Cloning ${config.repoUrl} (branch: ${config.branch})`,
+        async () => {
+          let sshMaterial;
+          if (config.gitSsh) {
+            const writeSecretFile = env.writeSecretFile;
+            if (!writeSecretFile) {
+              throw new Error(
+                "SSH-based GitHub auth isn't supported on this build runtime \u2014 use a token or the tunnel relay."
+              );
+            }
+            sshMaterial = await materializeGitSsh(
+              shellGitSshWriter({ exec, writeSecret: writeSecretFile }),
+              `${env.projectDir}.gitssh`,
+              config.gitSsh
+            );
+          }
+          const { cloneUrl, gitEnv: GIT_ENV, credFlag: CRED } = assembleGitClone({
+            repoUrl: config.repoUrl,
+            gitToken: config.gitToken,
+            gitCredentialHelperPath: config.gitCredentialHelperPath,
+            ssh: sshMaterial,
+            ambient: config.gitAmbient
+          });
+          try {
+            if (config.commitSha) {
+              try {
+                await exec(
+                  `${GIT_ENV} git ${CRED} clone --progress --depth 50 --branch ${sq(config.branch)} ${sq(cloneUrl)} ${sq(env.projectDir)} && cd ${sq(env.projectDir)} && git ${CRED} -c advice.detachedHead=false checkout ${sq(config.commitSha)}`
+                );
+              } catch {
+                logger.log(
+                  `Checkout of ${config.commitSha} failed inside the depth-50 clone; running git fetch --unshallow and retrying.`,
+                  "warn"
+                );
+                await exec(
+                  `cd ${sq(env.projectDir)} && ${GIT_ENV} git ${CRED} fetch --progress --unshallow && git ${CRED} -c advice.detachedHead=false checkout ${sq(config.commitSha)}`
+                );
+              }
+            } else {
+              await exec(
+                `${GIT_ENV} git ${CRED} clone --progress --depth 1 --branch ${sq(config.branch)} ${sq(cloneUrl)} ${sq(env.projectDir)}`
+              );
+            }
+          } finally {
+            await sshMaterial?.cleanup();
+          }
+        }
+      );
+    }
+    const envPrefix = env.hasNativeEnv ? "" : Object.entries(config.envVars).filter(([k]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(k)).map(([k, v]) => `export ${k}=${sq(v)}`).join(" && ");
+    const JS_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "yarn", "pnpm", "bun"]);
+    const binPathExport = JS_PACKAGE_MANAGERS.has(config.packageManager) ? `export PATH=${sq(`${buildDir}/node_modules/.bin`)}:${sq(`${env.projectDir}/node_modules/.bin`)}:"$PATH"` : "";
+    const inDir = (cmd) => {
+      const full = `cd ${sq(buildDir)} && ${cmd}`;
+      const prefix = [envPrefix, binPathExport].filter(Boolean).join(" && ");
+      return prefix ? `${prefix} && ${full}` : full;
+    };
+    const pmEnsure = packageManagerEnsureCommand(config.packageManager);
+    currentStep = "install";
+    if (config.installCommand) {
+      const installCmd = pmEnsure ? `${pmEnsure} && ${config.installCommand}` : config.installCommand;
+      await logger.runStep(
+        "install",
+        `Installing dependencies (${config.packageManager})`,
+        async () => {
+          await exec(inDir(installCmd));
+        }
+      );
+    } else {
+      logger.step("install", "skipped", "No install command configured");
+    }
+    if (config.buildCommand) {
+      currentStep = "build";
+      const buildCmd = pmEnsure && !config.installCommand ? `${pmEnsure} && ${config.buildCommand}` : config.buildCommand;
+      await logger.runStep("build", `Building (${config.buildCommand})`, async () => {
+        await exec(inDir(buildCmd));
+      });
+    } else {
+      logger.step("build", "skipped", "No build command configured");
+    }
+    const durationMs = Date.now() - startTime;
+    return { status: "deploying", durationMs };
+  } catch (err) {
+    const durationMs = Date.now() - startTime;
+    if (err instanceof BuildCancelledError) {
+      return { status: "cancelled", durationMs, errorMessage: err.message };
+    }
+    const errorMessage = safeErrorMessage(err);
+    return { status: "failed", failedStep: currentStep, durationMs, errorMessage };
+  }
+}
+function resolveBuildDirectory(projectDir, rootDirectory) {
+  const normalized = rootDirectory?.trim().replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === ".") {
+    return projectDir;
+  }
+  return `${projectDir}/${normalized}`;
+}
+function parseLogLevel(message) {
+  if (/\b(error|fatal|panic)\b/i.test(message)) return "error";
+  if (/\bwarn(ing)?\b/i.test(message)) return "warn";
+  return "info";
+}
+function detectBuildKillHint(output) {
+  if (!output) return null;
+  const tail = output.slice(-4096);
+  if (/\bsigkill\b|\bKilled\b|out of memory|JavaScript heap out of memory|Allocation failed/i.test(tail)) {
+    return "Build process was killed - typically because the target ran out of memory during the build. Increase RAM on the target, add swap, or build locally and ship the dist.";
+  }
+  return null;
+}
+
+// ../../packages/adapters/src/runtime/transfer.ts
+import { execFile } from "child_process";
+var TAR_MAX_BUFFER = 500 * 1024 * 1024;
+async function transferLocalDirectory(localPath, target, logger, options) {
+  logger.log(`Transferring ${localPath} \u2192 ${target.path}...
+`);
+  if (target.kind === "executor") {
+    await target.executor.transferIn(localPath, target.path, logger.callback, {
+      excludes: options?.excludes,
+      includes: options?.includes,
+      alsoInclude: options?.alsoInclude
+    });
+    await verifyExecutorTransfer(target.executor, target.path, logger);
+    return;
+  }
+  const tarBuffer = await createTarball(localPath, options);
+  const result = await target.runtime.transfer.upload({
+    body: tarBuffer,
+    dest: target.path
+  });
+  if (!result.files_extracted || result.files_extracted === 0) {
+    throw new Error("Transfer produced 0 files - upload may have failed silently");
+  }
+  logger.log(`Uploaded ${result.files_extracted} files.
+`);
+}
+async function verifyExecutorTransfer(executor, targetPath, logger) {
+  try {
+    const countOutput = await executor.exec(
+      `find ${sq(targetPath)} -mindepth 1 -maxdepth 1 | head -5 | wc -l`
+    );
+    const fileCount = parseInt(countOutput.trim(), 10);
+    if (fileCount === 0) {
+      throw new Error(
+        `Transfer target ${targetPath} is empty - files were not copied`
+      );
+    }
+    logger.log(`Transfer verified (${fileCount}+ entries in target).
+`);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("is empty")) throw err;
+    throw new Error(
+      `Transfer verification failed: ${safeErrorMessage(err)}`
+    );
+  }
+}
+async function createTarball(localPath, options) {
+  const { args, cleanup } = await prepareSourceTarArgs(localPath, {
+    excludes: options?.excludes ?? [...TRANSFER_EXCLUDES],
+    includes: options?.includes,
+    alsoInclude: options?.alsoInclude
+  });
+  try {
+    return await new Promise((resolve, reject) => {
+      execFile(
+        "tar",
+        args,
+        {
+          encoding: "buffer",
+          maxBuffer: TAR_MAX_BUFFER,
+          env: getTarCreateEnv()
+        },
+        (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));
+        }
+      );
+    });
+  } finally {
+    await cleanup();
+  }
+}
+
+export {
+  sq,
+  injectGitToken,
+  assembleGitClone,
+  materializeGitSsh,
+  shellGitSshWriter,
+  localGitSshWriter,
+  BuildLogger,
+  BuildCancelledError,
+  runBuildPipeline,
+  parseLogLevel,
+  detectBuildKillHint,
+  transferLocalDirectory
+};