openship 0.6.6 → 0.6.8

package/dist/{chunk-LFE5KQ7Y.js → chunk-ENKJ7XIF.js}

@@ -7,42 +7,59 @@ import {
   resolveProjectDir,
   resolveStaticOutputPath,
   runLocalBuild
-} from "./chunk-YIMOCZBZ.js";
+} from "./chunk-5DJOB7IX.js";
+import {
+  isArtifactPathRef,
+  removeManagedArtifact
+} from "./chunk-SK4FFCFR.js";
 import {
   BuildCancelledError,
   BuildLogger,
   detectBuildKillHint,
+  droppedRuntimeEnvMessage,
+  isExcludedDocRootEntry,
   killProcessesUnderDir,
   parseLogLevel,
   runBuildPipeline,
+  splitRuntimeEnv,
   sq,
   transferLocalDirectory
-} from "./chunk-LH2PLRQO.js";
+} from "./chunk-AHJYP7DG.js";
 import {
   LocalExecutor
-} from "./chunk-6FH4AXVY.js";
+} from "./chunk-T6DVUX4F.js";
 import {
   privilegedExecutor
-} from "./chunk-4I2BM2DT.js";
+} from "./chunk-T46BQOLY.js";
 import {
   HOST_STATE_DIR,
   envOps,
   hostRefusal,
   opScript
-} from "./chunk-YMMQRE5J.js";
+} from "./chunk-GNOMEMNI.js";
 import {
   ensureOwnedDir,
   resolveEnvironment
-} from "./chunk-UVNMQM7W.js";
+} from "./chunk-NPSRGIHV.js";
 import {
   sq as sq2,
   wrapLocalBuildCommand
-} from "./chunk-ZFJXPCQP.js";
+} from "./chunk-P7RCYELG.js";
+import {
+  portOccupantDetails,
+  probeListeningPort
+} from "./chunk-BO6CY4V2.js";
 import {
+  managedDeploymentUnitName,
   probeExec,
-  probeListeningPort,
   withReason
-} from "./chunk-SM26HDS2.js";
+} from "./chunk-D6HU4VUZ.js";
+import {
+  formatDuration,
+  isRemoteConnectionError,
+  isRetryableRemoteConnectionError,
+  systemDebug
+} from "./chunk-N5YZMO33.js";
 import {
   DeployError,
   LANGUAGES,
@@ -50,16 +67,13 @@ import {
   answered,
   appVolumeTargets,
   buildOutputTransferExcludes,
-  formatDuration,
-  isRemoteConnectionError,
-  isRetryableRemoteConnectionError,
   missingOutputDirectoryMessage,
+  nodeBinPathExport,
   packageManagerEnsureCommand,
   refused,
   safeErrorMessage,
-  shellQuote,
-  systemDebug
-} from "./chunk-UJ6JZM65.js";
+  shellQuote
+} from "./chunk-WEZFTL4V.js";
 
 // ../../packages/adapters/src/system/remote-journal.ts
 var OPSH_RUN_VERSION = 1;
@@ -1114,7 +1128,6 @@ async function sampleBareUsage(executor, pid, cgroupCandidates = []) {
 }
 
 // ../../packages/adapters/src/runtime/supervisor/systemd.ts
-var UNIT_PREFIX = "openship";
 function escapeSystemdEnvValue(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
 }
@@ -1126,7 +1139,7 @@ var SystemdSupervisor = class {
   name = "systemd";
   // ── Helpers ──────────────────────────────────────────────────────────
   unitName(deploymentId) {
-    return `${UNIT_PREFIX}-${deploymentId}.service`;
+    return managedDeploymentUnitName(deploymentId);
   }
   unitPath(deploymentId) {
     return `/etc/systemd/system/${this.unitName(deploymentId)}`;
@@ -1172,7 +1185,7 @@ Restart=on-failure
 RestartSec=3
 StandardOutput=journal
 StandardError=journal
-SyslogIdentifier=${UNIT_PREFIX}-${opts.deploymentId}
+SyslogIdentifier=${this.unitName(opts.deploymentId).replace(/\.service$/, "")}
 
 [Install]
 WantedBy=multi-user.target
@@ -1206,16 +1219,7 @@ WantedBy=multi-user.target
         throw new DeployError(
           `Port ${opts.port} is already in use` + (occupant ? ` by ${occupant.command}` : "") + ". Stop the existing process before deploying.",
           "PORT_IN_USE",
-          {
-            port: opts.port,
-            pid: occupant?.pid,
-            command: occupant?.command,
-            rawCommand: occupant?.rawCommand,
-            systemdUnit: occupant?.systemdUnit,
-            systemdDescription: occupant?.systemdDescription,
-            deploymentId: occupant?.deploymentId,
-            isManagedDeployment: occupant?.isManagedDeployment
-          }
+          portOccupantDetails(opts.port, occupant)
         );
       }
       const msg = hint ? `Process exited immediately after start. Last output:
@@ -1424,7 +1428,7 @@ var NohupSupervisor = class {
         throw new DeployError(
           `Port ${opts.port} is already in use` + (occupant ? ` by ${occupant.command}` : "") + ". Stop the existing process before deploying.",
           "PORT_IN_USE",
-          { port: opts.port, pid: occupant?.pid, command: occupant?.command }
+          portOccupantDetails(opts.port, occupant)
         );
       }
       const msg = hint ? `Process exited immediately after spawn. Last output:
@@ -1604,6 +1608,16 @@ var BareRuntime = class {
   async inContainerExecutor() {
     return this.executor;
   }
+  /**
+   * Resolve a retained application release for an env-only refresh.
+   * Deployment ids originate in our database, but reject path-shaped input at
+   * this boundary so an imported/corrupt row cannot escape releases/.
+   */
+  async retainedReleaseArtifact(deploymentId) {
+    if (!deploymentId || deploymentId.includes("/") || deploymentId.includes("\\")) return null;
+    const path = this.releaseDir(deploymentId);
+    return await this.executor.exists(path).catch(() => false) ? path : null;
+  }
   /** Get or lazily initialise the process supervisor. */
   async supervisor() {
     if (this._supervisor) return this._supervisor;
@@ -1690,6 +1704,7 @@ var BareRuntime = class {
   async promoteBuildArtifact(artifactPath, deploymentId, previousDeploymentId) {
     const releaseDir = this.releaseDir(deploymentId);
     if (artifactPath === releaseDir) return releaseDir;
+    const consumeSource = !artifactPath.startsWith(`${this.workDir}/releases/`);
     await ensureOwnedDir(this.executor, `${this.workDir}/releases`);
     await this.executor.rm(releaseDir);
     const previousReleaseDir = previousDeploymentId ? this.releaseDir(previousDeploymentId) : void 0;
@@ -1700,7 +1715,7 @@ var BareRuntime = class {
           `deploy:${deploymentId}:promote-rsync`,
           `rsync -a --delete --link-dest=${sq(previousReleaseDir)} ${sq(artifactPath)}/ ${sq(releaseDir)}/`
         );
-        await this.executor.rm(artifactPath).catch(() => {
+        if (consumeSource) await this.executor.rm(artifactPath).catch(() => {
         });
         return releaseDir;
       } catch {
@@ -1708,6 +1723,14 @@ var BareRuntime = class {
         });
       }
     }
+    if (!consumeSource) {
+      await execReliable(
+        this.executor,
+        `deploy:${deploymentId}:promote-copy`,
+        `mkdir -p ${sq(releaseDir)} && cp -a ${sq(artifactPath)}/. ${sq(releaseDir)}/`
+      );
+      return releaseDir;
+    }
     await execReliable(
       this.executor,
       `deploy:${deploymentId}:promote-mv`,
@@ -1947,19 +1970,29 @@ var BareRuntime = class {
     ) : stagedDir;
     await this.linkPersistentPaths(workDir, config.projectId, config.volumes, _onLog);
     const sv = await this.supervisor();
+    const projectEnv = splitRuntimeEnv(
+      Object.fromEntries(Object.entries(config.envVars ?? {}).map(([k, v]) => [k, String(v)]))
+    );
+    if (projectEnv.dropped.length > 0) {
+      _onLog?.({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "warn",
+        message: droppedRuntimeEnvMessage(projectEnv.dropped)
+      });
+    }
     const env = {
-      ...Object.fromEntries(
-        Object.entries(config.envVars ?? {}).map(([k, v]) => [k, String(v)])
-      ),
+      ...Object.fromEntries(projectEnv.entries),
       PORT: String(config.port),
       NODE_ENV: config.environment === "production" ? "production" : "development"
     };
+    const startBinPath = nodeBinPathExport(config.packageManager, [workDir]);
+    const resolvedStart = config.startCommand || "npm start";
     try {
       await sv.deploy({
         deploymentId: config.deploymentId,
         projectId: config.projectId,
         workDir,
-        startCommand: config.startCommand || "npm start",
+        startCommand: startBinPath ? `${startBinPath} && ${resolvedStart}` : resolvedStart,
         port: config.port,
         env
       });
@@ -1979,13 +2012,40 @@ var BareRuntime = class {
     };
   }
   async deployStatic(config) {
-    const stagedDir = config.imageRef ?? this.projectDir(config.projectId);
-    const workDir = config.imageRef ? await this.promoteBuildArtifact(
-      stagedDir,
-      config.deploymentId,
-      config.previousDeploymentId
-    ) : stagedDir;
-    const staticRoot = resolveStaticOutputPath(workDir, config.outputDirectory);
+    const workDir = await this.promoteStaticRelease({
+      artifactPath: config.imageRef ?? this.projectDir(config.projectId),
+      releaseId: config.deploymentId,
+      previousReleaseId: config.previousDeploymentId,
+      outputDirectory: config.outputDirectory,
+      promote: Boolean(config.imageRef)
+    });
+    return {
+      deploymentId: config.deploymentId,
+      containerId: workDir,
+      status: "running"
+    };
+  }
+  /**
+   * Promote an extracted static build into a stable release directory and PROVE it
+   * can serve, returning the release dir.
+   *
+   * Split out of `deployStatic` so the compose/monorepo static path reuses the
+   * identical promote + validation instead of registering a vhost straight at the
+   * `.builds/<session>` staging dir. Two things came from that shortcut: the
+   * public doc-root of a compose static sub-app was a per-build-session scratch
+   * directory (nothing owned its lifetime, so superseded copies accumulated and
+   * any sweep of `.builds` would take the live site down), and it skipped the only
+   * HARD deploy-time output gate we have — so an extract that produced nothing
+   * deployed green and 404'd.
+   *
+   * `releaseId` is the release's identity, not necessarily a deployment id: the
+   * compose path passes `<deploymentId>-<serviceId>` so each static sub-app owns
+   * its own release dir under one deployment.
+   */
+  async promoteStaticRelease(opts) {
+    const stagedDir = opts.artifactPath;
+    const workDir = opts.promote === false ? stagedDir : await this.promoteBuildArtifact(stagedDir, opts.releaseId, opts.previousReleaseId);
+    const staticRoot = resolveStaticOutputPath(workDir, opts.outputDirectory);
     const abort = async (message) => {
       if (workDir !== stagedDir) {
         await this.executor.rm(workDir).catch(() => {
@@ -1994,18 +2054,47 @@ var BareRuntime = class {
       throw new Error(message);
     };
     if (!await this.executor.exists(staticRoot)) {
-      return abort(missingOutputDirectoryMessage(config.outputDirectory));
+      return abort(missingOutputDirectoryMessage(opts.outputDirectory));
+    }
+    if (staticRoot === workDir) {
+      const undeleted = await this.pruneBuildFilesFromDocRoot(staticRoot);
+      if (undeleted.length > 0) {
+        return abort(
+          `Refusing to publish ${staticRoot}: could not remove ${undeleted.join(", ")} from the document root. Serving them would expose the repository (and, for a private repo, the access token in .git/config) at the site's public URL.`
+        );
+      }
     }
     if (await this.isEmptyDir(staticRoot)) {
       return abort(
-        `The output directory "${config.outputDirectory || "."}" is empty \u2014 the build produced no files to serve, so every request would 404. Check the build command and the Output Directory setting.`
+        `The output directory "${opts.outputDirectory || "."}" is empty \u2014 the build produced no files to serve, so every request would 404. Check the build command and the Output Directory setting.`
       );
     }
-    return {
-      deploymentId: config.deploymentId,
-      containerId: workDir,
-      status: "running"
-    };
+    return workDir;
+  }
+  /**
+   * Remove top-level build inputs from a doc root, returning the names it could NOT
+   * remove (empty on success, and on "there was nothing to remove").
+   *
+   * Reuses `isExcludedDocRootEntry` rather than re-listing the names, because the
+   * Docker sandbox already owns that list and two copies of "what must not be
+   * served" is precisely how the bare path came to serve `.git`.
+   *
+   * An unreadable listing returns empty — a probe that cannot read must not fail a
+   * deploy — but a listed entry that survives its `rm` is reported, because the
+   * caller must refuse to publish rather than expose a token.
+   */
+  async pruneBuildFilesFromDocRoot(root) {
+    const listed = await this.executor.exec(`ls -A ${sq(root)} 2>/dev/null; true`).catch(() => null);
+    if (listed === null) return [];
+    const doomed = listed.split("\n").map((l) => l.trim()).filter(Boolean).filter(isExcludedDocRootEntry);
+    if (doomed.length === 0) return [];
+    await this.executor.exec(`rm -rf ${doomed.map((n) => sq(`${root}/${n}`)).join(" ")}`).catch(() => {
+    });
+    const survivors = [];
+    for (const name of doomed) {
+      if (await this.executor.exists(`${root}/${name}`)) survivors.push(name);
+    }
+    return survivors;
   }
   /**
    * Is this an existing directory with no entries? Any inconclusive answer (not a
@@ -2033,8 +2122,8 @@ var BareRuntime = class {
     await sv.restart(containerId);
   }
   async destroy(containerId) {
-    if (containerId.includes("/")) {
-      await this.executor.rm(containerId);
+    if (isArtifactPathRef(containerId)) {
+      await removeManagedArtifact(this.executor, containerId);
       return;
     }
     const sv = await this.supervisor();
@@ -2078,15 +2167,21 @@ var BareRuntime = class {
     }
   }
   async purge(deployment) {
+    const failures = [];
     if (deployment.containerId) {
-      try {
-        await this.destroy(deployment.containerId);
-      } catch {
-      }
+      await this.destroy(deployment.containerId).catch((err) => failures.push(err));
     }
-    try {
-      await this.executor.rm(this.releaseDir(deployment.id));
-    } catch {
+    const releaseDir = this.releaseDir(deployment.id);
+    if (releaseDir !== deployment.containerId) {
+      await removeManagedArtifact(this.executor, releaseDir).catch(
+        (err) => failures.push(err)
+      );
+    }
+    if (failures.length === 1) throw failures[0];
+    if (failures.length > 1) {
+      throw new Error(
+        failures.map((err) => err instanceof Error ? err.message : String(err)).join("; ")
+      );
     }
   }
   // ── Observability ──────────────────────────────────────────────────────

package/dist/{chunk-YMMQRE5J.js → chunk-GNOMEMNI.js}

@@ -9,7 +9,7 @@ import {
   firewallPersists,
   refused,
   shellQuote
-} from "./chunk-UJ6JZM65.js";
+} from "./chunk-WEZFTL4V.js";
 
 // ../../packages/adapters/src/system/environment-ops.ts
 function opScript(steps) {