openship 0.3.0 → 0.4.1

package/dist/chunk-4CQWT2WL.js

@@ -0,0 +1,116 @@
+// ../../packages/adapters/src/system/local-shell.ts
+import { execFile } from "child_process";
+import { basename } from "path";
+var LOCAL_BUILD_ENV_KEYS = [
+  "HOME",
+  "PATH",
+  "SHELL",
+  "USER",
+  "LOGNAME",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "COLORTERM",
+  "SSH_AUTH_SOCK",
+  "SSH_AGENT_PID",
+  "GIT_SSH_COMMAND",
+  "GIT_ASKPASS",
+  "XDG_CONFIG_HOME",
+  "XDG_CACHE_HOME",
+  "XDG_DATA_HOME"
+];
+function sq(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function logEntry(message, level = "info", rawData) {
+  return { timestamp: (/* @__PURE__ */ new Date()).toISOString(), message, level, ...rawData ? { rawData } : {} };
+}
+function getLocalShellPath() {
+  return process.env.SHELL?.trim() || "/bin/sh";
+}
+function getLocalShellArgs(command) {
+  const shellName = basename(getLocalShellPath());
+  if (shellName === "bash" || shellName === "zsh") {
+    return ["-lc", command];
+  }
+  return ["-c", command];
+}
+function getLocalExecEnv() {
+  return { ...process.env, DEBIAN_FRONTEND: "noninteractive", DPKG_FORCE: "confnew" };
+}
+async function execFileText(command, args, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { timeout }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(stderr.trim() || stdout.trim() || err.message));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+async function hasLocalCommand(command) {
+  try {
+    await execFileText("sh", ["-c", `command -v ${command} >/dev/null 2>&1 && echo ok`], 4e3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function emitBufferedLines(chunk, state, onLine) {
+  const text = `${state.partial}${chunk.toString()}`.replace(/\r/g, "\n");
+  const parts = text.split("\n");
+  state.partial = parts.pop() ?? "";
+  for (const raw of parts) {
+    const line = raw.trimEnd();
+    if (line) {
+      onLine(line);
+    }
+  }
+}
+function flushBufferedLines(state, onLine) {
+  const line = state.partial.trimEnd();
+  state.partial = "";
+  if (line) {
+    onLine(line);
+  }
+}
+function buildIsolatedLocalEnv(overrides) {
+  const env = { DEBIAN_FRONTEND: "noninteractive", DPKG_FORCE: "confnew" };
+  for (const key of LOCAL_BUILD_ENV_KEYS) {
+    const value = process.env[key];
+    if (value) {
+      env[key] = value;
+    }
+  }
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      if (typeof value === "string") {
+        env[key] = value;
+      }
+    }
+  }
+  return env;
+}
+function wrapLocalBuildCommand(command, envOverrides) {
+  const shellPath = getLocalShellPath();
+  const envVars = buildIsolatedLocalEnv(envOverrides);
+  const envAssignments = Object.entries(envVars).filter((entry) => typeof entry[1] === "string").map(([key, value]) => `${key}=${sq(value)}`).join(" ");
+  return `env -i ${envAssignments} ${sq(shellPath)} ${getLocalShellArgs(command).map(sq).join(" ")}`;
+}
+
+export {
+  sq,
+  logEntry,
+  getLocalShellPath,
+  getLocalShellArgs,
+  getLocalExecEnv,
+  hasLocalCommand,
+  emitBufferedLines,
+  flushBufferedLines,
+  wrapLocalBuildCommand
+};

package/dist/chunk-4FABQGQP.js

@@ -0,0 +1,23 @@
+// ../../packages/adapters/src/infra/noop.ts
+var NoopInfraProvider = class {
+  async registerRoute(_route) {
+  }
+  async removeRoute(_domain) {
+  }
+  async provisionCert(domain) {
+    return { domain, expiresAt: "", issuer: "none", verified: false };
+  }
+  async renewCert(domain) {
+    return { domain, expiresAt: "", issuer: "none", verified: false };
+  }
+  async verifyCert(domain) {
+    return { domain, expiresAt: "", issuer: "none", verified: false };
+  }
+  async installCert(domain, _cert) {
+    return { domain, expiresAt: "", issuer: "none", verified: false };
+  }
+};
+
+export {
+  NoopInfraProvider
+};

package/dist/chunk-4LEL3H2Z.js

@@ -0,0 +1,84 @@
+// ../../packages/adapters/src/system/errors.ts
+var SSH_AUTH_ERROR_PATTERNS = [
+  "All configured authentication methods failed"
+];
+var RETRYABLE_CONNECTION_ERROR_PATTERNS = [
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "Timed out",
+  "Not connected",
+  "Connection lost",
+  "read ECONNRESET",
+  "Handshake failed",
+  "keepalive timeout",
+  "SSH connection closed before ready",
+  // ssh2 emits "Channel open failure: open failed" / "Channel open failure: …"
+  // when the SSH SERVER refuses a new channel - typically because the cached
+  // connection has gone half-dead (peer-side LOGOUT, network blip,
+  // remote sshd MaxSessions). The inner SshExecutor retries `exec`/
+  // `streamExec` on this, but `pipeLocal`, `transferIn`, and any other
+  // channel-bearing op bubble it up. Listing it here lets `withExecutor`
+  // drop the dead connection and retry transparently - fixes the
+  // "first redeploy fails, second click works" pattern.
+  "Channel open failure",
+  "open failed"
+];
+var SshDisconnectedError = class extends Error {
+  constructor(message = "SSH connection lost") {
+    super(message);
+    this.name = "SshDisconnectedError";
+  }
+};
+function isSshDisconnectedError(err) {
+  return err instanceof SshDisconnectedError || err instanceof Error && err.name === "SshDisconnectedError";
+}
+function isSshAuthError(err) {
+  if (!(err instanceof Error)) return false;
+  return SSH_AUTH_ERROR_PATTERNS.some((pattern) => err.message.includes(pattern));
+}
+function isRetryableRemoteConnectionError(err) {
+  if (isSshDisconnectedError(err)) return true;
+  if (!(err instanceof Error)) return false;
+  return RETRYABLE_CONNECTION_ERROR_PATTERNS.some(
+    (pattern) => err.message.includes(pattern)
+  );
+}
+function isRemoteConnectionError(err) {
+  return isSshAuthError(err) || isRetryableRemoteConnectionError(err);
+}
+function isRuntimeNotFoundError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.statusCode === 404) return true;
+  return typeof e.message === "string" && /no such (container|image|volume|network)/i.test(e.message);
+}
+
+// ../../packages/adapters/src/system/debug.ts
+function isTruthy(value) {
+  if (!value) return false;
+  return ["1", "true", "yes", "on", "debug"].includes(value.toLowerCase());
+}
+function isSystemDebugEnabled() {
+  return isTruthy(process.env.SYSTEM_DEBUG_LOGS);
+}
+function systemDebug(scope, message) {
+  if (!isSystemDebugEnabled()) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  console.log(`[system-debug] ${timestamp} [${scope}] ${message}`);
+}
+function formatDuration(startMs) {
+  return `${Date.now() - startMs}ms`;
+}
+
+export {
+  SshDisconnectedError,
+  isSshAuthError,
+  isRetryableRemoteConnectionError,
+  isRemoteConnectionError,
+  isRuntimeNotFoundError,
+  systemDebug,
+  formatDuration
+};

package/dist/chunk-4MG3BVHE.js

@@ -0,0 +1,326 @@
+import {
+  isSshAuthError,
+  systemDebug
+} from "./chunk-4LEL3H2Z.js";
+import {
+  PACKAGE_ROOT_ONLY_EXCLUDES
+} from "./chunk-JZLNHGLW.js";
+
+// ../../packages/adapters/src/archive.ts
+import { execFile } from "child_process";
+import { mkdtemp, rm, stat, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var ROOT_ONLY_EXCLUDES = new Set(PACKAGE_ROOT_ONLY_EXCLUDES);
+var NOOP_CLEANUP = async () => {
+};
+function getTarCreateEnv() {
+  return {
+    ...process.env,
+    COPYFILE_DISABLE: "1",
+    COPY_EXTENDED_ATTRIBUTES_DISABLE: "1"
+  };
+}
+function tarCreateBaseArgs(localPath) {
+  const darwinFlags = process.platform === "darwin" ? ["--no-mac-metadata", "--no-xattrs", "--no-acls", "--no-fflags"] : [];
+  return [...darwinFlags, "-czf", "-", "-C", localPath];
+}
+async function gitTrackedFiles(localPath) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["-C", localPath, "ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+      { maxBuffer: 256 * 1024 * 1024 }
+    );
+    const files = stdout.split("\0").filter(Boolean);
+    return files.length > 0 ? files : null;
+  } catch {
+    return null;
+  }
+}
+async function existingRelativePaths(root, paths) {
+  if (!paths?.length) return [];
+  const found = [];
+  for (const p of paths) {
+    try {
+      await stat(join(root, p));
+      found.push(p);
+    } catch {
+    }
+  }
+  return found;
+}
+async function prepareSourceTarArgs(localPath, options) {
+  if (options?.includes?.length) {
+    return { args: getTarCreateArgs(localPath, options), cleanup: NOOP_CLEANUP };
+  }
+  const files = await gitTrackedFiles(localPath);
+  if (files) {
+    const extra = await existingRelativePaths(localPath, options?.alsoInclude);
+    const entries = extra.length ? [...files, ...extra] : files;
+    const tmpDir = await mkdtemp(join(tmpdir(), "openship-tarlist-"));
+    const listFile = join(tmpDir, "files.null");
+    await writeFile(listFile, entries.join("\0"));
+    const args = [...tarCreateBaseArgs(localPath), "--null", "-T", listFile];
+    return { args, cleanup: () => rm(tmpDir, { recursive: true, force: true }) };
+  }
+  return { args: getTarCreateArgs(localPath, options), cleanup: NOOP_CLEANUP };
+}
+function getTarCreateArgs(localPath, options) {
+  const args = tarCreateBaseArgs(localPath);
+  if (options?.includes?.length) {
+    args.push(...options.includes);
+    return args;
+  }
+  for (const exclude of options?.excludes ?? []) {
+    const pattern = ROOT_ONLY_EXCLUDES.has(exclude) ? `./${exclude}` : exclude;
+    args.push(`--exclude=${pattern}`);
+  }
+  args.push(".");
+  return args;
+}
+
+// ../../packages/adapters/src/system/ssh-client.ts
+import { Client } from "ssh2";
+
+// ../../packages/adapters/src/system/ssh-support.ts
+import { execFile as execFile2 } from "child_process";
+import { access } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+function formatSshTarget(config) {
+  return `${config.username ?? "root"}@${config.host}:${config.port ?? 22}`;
+}
+function describeSshAuthFailure(config, originalMessage) {
+  const target = formatSshTarget(config);
+  if (config.password) {
+    return `SSH password authentication failed for ${target}. Check the username/password, or verify that the server allows password login. (${originalMessage})`;
+  }
+  if (config.privateKey || config.sshAgent) {
+    return `SSH key authentication failed for ${target}. Check the username, private key, passphrase, or whether the server accepts this key. (${originalMessage})`;
+  }
+  return `SSH authentication failed for ${target}. (${originalMessage})`;
+}
+function execFileText(command, args, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    execFile2(command, args, { timeout }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(stderr.trim() || stdout.trim() || err.message));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+function parseKnownHostsEntries(text) {
+  const entries = /* @__PURE__ */ new Set();
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length >= 3) {
+      entries.add(`${parts[1]} ${parts[2]}`);
+    }
+  }
+  return entries;
+}
+async function reconcileKnownHosts(config) {
+  const knownHostsPath = join2(homedir(), ".ssh", "known_hosts");
+  try {
+    await access(knownHostsPath);
+  } catch {
+    return;
+  }
+  const port = config.port ?? 22;
+  const hostPatterns = port === 22 ? [config.host] : [config.host, `[${config.host}]:${port}`];
+  const knownEntries = /* @__PURE__ */ new Set();
+  for (const pattern of hostPatterns) {
+    try {
+      const output = await execFileText(
+        "ssh-keygen",
+        ["-F", pattern, "-f", knownHostsPath],
+        4e3
+      );
+      for (const entry of parseKnownHostsEntries(output)) {
+        knownEntries.add(entry);
+      }
+    } catch {
+    }
+  }
+  if (knownEntries.size === 0) return;
+  let scanned;
+  try {
+    scanned = await execFileText(
+      "ssh-keyscan",
+      ["-p", String(port), "-T", "5", config.host],
+      7e3
+    );
+  } catch {
+    return;
+  }
+  const scannedEntries = parseKnownHostsEntries(scanned);
+  if (scannedEntries.size === 0) return;
+  for (const entry of knownEntries) {
+    if (scannedEntries.has(entry)) {
+      return;
+    }
+  }
+  for (const pattern of hostPatterns) {
+    try {
+      await execFileText(
+        "ssh-keygen",
+        ["-R", pattern, "-f", knownHostsPath],
+        4e3
+      );
+      systemDebug(
+        "ssh-known-hosts",
+        `removed stale known_hosts entry for ${pattern}`
+      );
+    } catch {
+    }
+  }
+}
+
+// ../../packages/adapters/src/system/ssh-client.ts
+function toHostVerifier(config) {
+  if (!config.hostVerifier) {
+    return void 0;
+  }
+  return (key) => config.hostVerifier(Buffer.isBuffer(key) ? key : Buffer.from(key));
+}
+function toConnectConfig(config) {
+  return {
+    host: config.host,
+    port: config.port ?? 22,
+    username: config.username ?? "root",
+    hostVerifier: toHostVerifier(config),
+    password: config.password,
+    privateKey: config.privateKey,
+    passphrase: config.privateKeyPassphrase,
+    agent: config.sshAgent,
+    tryKeyboard: false,
+    keepaliveInterval: 15e3,
+    // 10 (~150s) rather than 3 (45s): a small server pegged by a heavy
+    // `docker build` / `bun install` can briefly starve sshd of keepalive
+    // replies, and 45s was dropping the SSH channel mid-build (build failed with
+    // a bare "exited with code 1"). Still detects a truly-dead link within ~2.5m.
+    keepaliveCountMax: 10
+  };
+}
+async function connectSshClient(config) {
+  await reconcileKnownHosts(config);
+  const client = new Client();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    client.on("ready", () => {
+      if (settled) return;
+      settled = true;
+      resolve(client);
+    });
+    client.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      if (isSshAuthError(err)) {
+        reject(new Error(describeSshAuthFailure(config, err.message)));
+        return;
+      }
+      reject(err);
+    });
+    client.on("close", () => {
+      if (settled) return;
+      settled = true;
+      reject(new Error("SSH connection closed before ready"));
+    });
+    client.connect(toConnectConfig(config));
+  });
+}
+async function openSftp(client) {
+  return new Promise((resolve, reject) => {
+    client.sftp((err, sftp) => {
+      if (err) reject(err);
+      else resolve(sftp);
+    });
+  });
+}
+async function openSshUnixSocket(client, socketPath) {
+  return new Promise((resolve, reject) => {
+    if (!client.openssh_forwardOutStreamLocal) {
+      reject(new Error("SSH server/client does not support OpenSSH streamlocal socket forwarding."));
+      return;
+    }
+    client.openssh_forwardOutStreamLocal(socketPath, (err, stream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(stream);
+    });
+  });
+}
+async function openSshExecChannel(client, command) {
+  return new Promise((resolve, reject) => {
+    client.exec(command, (err, stream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve(stream);
+    });
+  });
+}
+async function execSshCommand(client, command, timeout = 1e4) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    let stream;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      if (stream) {
+        try {
+          stream.close();
+        } catch {
+        }
+      }
+      reject(new Error(`SSH command timed out after ${timeout}ms: ${command}`));
+    }, timeout);
+    client.exec(command, (err, execStream) => {
+      if (err) {
+        clearTimeout(timer);
+        reject(err);
+        return;
+      }
+      stream = execStream;
+      if (timedOut) {
+        try {
+          stream.close();
+        } catch {
+        }
+        return;
+      }
+      stream.on("data", (chunk) => {
+        stdout += chunk.toString();
+      });
+      stream.stderr.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      stream.on("close", (code) => {
+        clearTimeout(timer);
+        resolve({ stdout: stdout.trim(), stderr: stderr.trim(), code: code ?? 1 });
+      });
+    });
+  });
+}
+
+export {
+  getTarCreateEnv,
+  prepareSourceTarArgs,
+  reconcileKnownHosts,
+  connectSshClient,
+  openSftp,
+  openSshUnixSocket,
+  openSshExecChannel,
+  execSshCommand
+};

package/dist/chunk-4VNS5WPM.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};