openship 0.6.7 → 0.6.8

package/dist/{chunk-CIJV43LH.js → chunk-MUWVC5R4.js}

@@ -5,16 +5,17 @@ const require = __ospCreateRequire(import.meta.url);
 import {
   checkGit,
   installGit
-} from "./chunk-ZPJ74LXE.js";
+} from "./chunk-NIYD7MD2.js";
 import {
-  createDockerBuildContext
-} from "./chunk-XWHWTHEL.js";
+  createDockerBuildContext,
+  resolveDockerBuildArgs
+} from "./chunk-6GU6JSK6.js";
 import {
   prepareStackOutput,
   resolveProjectDir,
   resolveStaticOutputPath,
   runLocalBuild
-} from "./chunk-MEE6OZFP.js";
+} from "./chunk-5DJOB7IX.js";
 import {
   BuildLogger,
   dockerBuildContextDirectory,
@@ -28,7 +29,7 @@ import {
   splitRuntimeEnv,
   sq,
   transferLocalDirectory
-} from "./chunk-H4FS5BED.js";
+} from "./chunk-AHJYP7DG.js";
 import {
   isRuntimeNotFoundError
 } from "./chunk-N5YZMO33.js";
@@ -43,7 +44,7 @@ import {
   packageManagerEnsureCommand,
   safeErrorMessage,
   shellSplitWords
-} from "./chunk-2VSW6Q6C.js";
+} from "./chunk-WEZFTL4V.js";
 
 // ../../packages/adapters/src/runtime/cloud.ts
 import { readFile } from "fs/promises";
@@ -1332,6 +1333,11 @@ function resolveCopyDestinationPath(copy, sourcePath, destination, destinationIs
 function cloudBuildContextPath(config) {
   return dockerBuildContextDirectory(config) || normalizeDockerRelativePath(config.rootDirectory);
 }
+function compileCloudDockerfilePlan(source, config) {
+  return compileDockerfileToWorkspacePlan(source, {
+    buildArgs: resolveDockerBuildArgs(config)
+  });
+}
 var PAGE_CONTAINER_PREFIX = "page:";
 async function provisionCloudWorkspace(client, config, logger) {
   logger?.log(`Creating workspace from image "${config.image}"...
@@ -1350,15 +1356,22 @@ async function provisionCloudWorkspace(client, config, logger) {
       }
     });
   } catch (err) {
-    logger?.log(`Failed to create workspace from image "${config.image}": ${formatCloudError(err)}
-`, "error");
+    logger?.log(
+      `Failed to create workspace from image "${config.image}": ${formatCloudError(err)}
+`,
+      "error"
+    );
     throw err;
   }
   const ws = client.workspace(wsData.id);
   try {
     if (config.mode === "temporary" && config.ttl) {
       try {
-        await ws.lifecycle.makeTemporary({ ttl: config.ttl, ttl_action: "remove", remove_on_exit: true });
+        await ws.lifecycle.makeTemporary({
+          ttl: config.ttl,
+          ttl_action: "remove",
+          remove_on_exit: true
+        });
       } catch {
       }
     }
@@ -1398,6 +1411,7 @@ var CloudRuntime = class {
   name = "cloud";
   capabilities = /* @__PURE__ */ new Set([
     "build",
+    "prebuiltImage",
     "deploy",
     "multiServiceDeploy",
     "stop",
@@ -1549,6 +1563,94 @@ var CloudRuntime = class {
     this.activeBuilds.get(sessionId)?.workspaceIds.delete(workspaceId);
   }
   // ── Build lifecycle ────────────────────────────────────────────────────
+  /**
+   * Materialize a prebuilt container image as the same opaque artifact Cloud's
+   * deploy path already understands: a temporary workspace id.
+   *
+   * Unlike a source build, no command is executed in the workspace. Creating it
+   * directly from the application image preserves the image's own ENTRYPOINT,
+   * CMD and WORKDIR; deploy keeps those defaults when `prebuiltImage` is set.
+   */
+  async prepareImage(config, logger) {
+    const log = logger ?? new BuildLogger();
+    const startedAt = Date.now();
+    const activeBuild = this.createActiveBuild(config.sessionId);
+    let workspaceId;
+    const discardWorkspace = async () => {
+      if (!workspaceId) return;
+      await this.ws(workspaceId).delete().catch(() => {
+      });
+      this.builtArtifacts.delete(workspaceId);
+      this.untrackActiveBuildWorkspace(config.sessionId, workspaceId);
+    };
+    const cancelled = async () => {
+      await discardWorkspace();
+      log.step("build", "failed", "Image preparation cancelled");
+      return {
+        sessionId: config.sessionId,
+        status: "cancelled",
+        // Keep the ref even after our best-effort delete: the pipeline can make
+        // an idempotent cleanup retry if that delete failed mid-cancellation.
+        imageRef: workspaceId,
+        durationMs: Date.now() - startedAt,
+        artifactOwned: true
+      };
+    };
+    try {
+      if (activeBuild.abort.signal.aborted) return await cancelled();
+      const imageRef = config.imageRef.trim();
+      if (!imageRef) throw new Error("Prebuilt image reference is required");
+      log.step("build", "running", `Creating workspace from prebuilt image ${imageRef}`);
+      const provisioned = await this.provisionWorkspace(
+        {
+          name: config.slug ?? `image-${config.projectId.slice(0, 20)}`,
+          image: imageRef,
+          mode: "temporary",
+          resources: config.resources,
+          env: config.envVars,
+          ttl: "15m"
+        },
+        log
+      );
+      workspaceId = provisioned.workspaceId;
+      this.trackActiveBuildWorkspace(config.sessionId, workspaceId);
+      if (activeBuild.abort.signal.aborted) return await cancelled();
+      this.builtArtifacts.set(workspaceId, {
+        workspaceId,
+        runtime: {
+          workdir: "/",
+          env: {},
+          exposedPorts: [],
+          baseImage: imageRef
+        }
+      });
+      log.step("build", "completed", `Prebuilt image workspace ${workspaceId} is ready`);
+      return {
+        sessionId: config.sessionId,
+        status: "deploying",
+        imageRef: workspaceId,
+        durationMs: Date.now() - startedAt,
+        artifactOwned: true
+      };
+    } catch (err) {
+      if (activeBuild.abort.signal.aborted) return await cancelled();
+      await discardWorkspace();
+      const message = formatCloudError(err);
+      log.step("build", "failed", `Image preparation failed: ${message}`);
+      return {
+        sessionId: config.sessionId,
+        status: "failed",
+        // Same retry contract as cancellation. Undefined means provisioning
+        // failed before Oblien handed us an owned workspace.
+        imageRef: workspaceId,
+        durationMs: Date.now() - startedAt,
+        errorMessage: `Image preparation failed: ${message}`,
+        artifactOwned: true
+      };
+    } finally {
+      this.activeBuilds.delete(config.sessionId);
+    }
+  }
   async build(config, logger) {
     const log = logger ?? new BuildLogger();
     const activeBuild = this.createActiveBuild(config.sessionId);
@@ -1607,7 +1709,9 @@ var CloudRuntime = class {
                 resolveProjectDir(buildDir, config.rootDirectory)
               );
               if (selfContained) {
-                log.log("Detected self-contained build output \u2014 uploading the bundle (no install on cloud).\n");
+                log.log(
+                  "Detected self-contained build output \u2014 uploading the bundle (no install on cloud).\n"
+                );
                 await transferLocalDirectory(
                   selfContained.bundleDir,
                   { kind: "cloud-runtime", runtime: rt, path: "/app" },
@@ -1645,7 +1749,11 @@ var CloudRuntime = class {
                 log.log("Installing production dependencies on cloud...\n");
                 const pmEnsure = packageManagerEnsureCommand(config.packageManager);
                 const fullInstall = pmEnsure ? `${pmEnsure} && ${installCmd}` : installCmd;
-                await this.execAndStream(rt, ["sh", "-c", `cd /app && ${fullInstall}`], log.callback);
+                await this.execAndStream(
+                  rt,
+                  ["sh", "-c", `cd /app && ${fullInstall}`],
+                  log.callback
+                );
               }
             }
           });
@@ -1730,7 +1838,7 @@ var CloudRuntime = class {
     try {
       log.log("Build strategy: Dockerfile plan (build in Oblien workspaces)\n");
       source = await this.resolveDockerfileBuildSource(config, log);
-      const plan = compileDockerfileToWorkspacePlan(source.dockerfile);
+      const plan = compileCloudDockerfilePlan(source.dockerfile, config);
       const blocking = plan.diagnostics.filter(
         (item) => item.severity === "error" || item.severity === "unsupported"
       );
@@ -1819,10 +1927,7 @@ var CloudRuntime = class {
       requireRepositoryDockerfile: true,
       onLog: logger.callback
     });
-    const dockerfilePath = resolveWithinDirectory(
-      context.buildContextDir,
-      context.dockerfileName
-    );
+    const dockerfilePath = resolveWithinDirectory(context.buildContextDir, context.dockerfileName);
     const dockerfile = await readFile(dockerfilePath, "utf-8");
     const contextRoot = context.contextSubdir ? context.buildContextDir : resolveWithinDirectory(context.contextDir, context.rootDirectory);
     return {
@@ -1885,11 +1990,9 @@ var CloudRuntime = class {
         logger.log(`Checking Dockerfile candidate: ${candidate}
 `);
         const dockerfile = await executor.exec(
-          [
-            `cd ${sq(sourceDir)}`,
-            `test -f ${sq(candidate)}`,
-            `cat ${sq(candidate)}`
-          ].join(" && "),
+          [`cd ${sq(sourceDir)}`, `test -f ${sq(candidate)}`, `cat ${sq(candidate)}`].join(
+            " && "
+          ),
           { timeout: 3e4 }
         ).catch(() => null);
         if (dockerfile !== null) {
@@ -2119,8 +2222,10 @@ var CloudRuntime = class {
       ...prepareContextCommands,
       'echo "Dockerfile context prepared."'
     ].join("\n");
-    logger.log(`Preparing Dockerfile build workspace for repository clone (branch: ${config.branch})...
-`);
+    logger.log(
+      `Preparing Dockerfile build workspace for repository clone (branch: ${config.branch})...
+`
+    );
     await this.ensureWorkspaceGit(targetRuntime, logger, "Dockerfile build workspace");
     logger.log(`Cloning Dockerfile context in build workspace (branch: ${config.branch})...
 `);
@@ -2373,8 +2478,8 @@ var CloudRuntime = class {
       }
     }
     const builtArtifact = this.builtArtifacts.get(workspaceId);
-    const prodPaths = config.productionPaths;
-    const workDir = builtArtifact?.runtime.workdir ?? (prodPaths?.length ? "/app/production" : "/app");
+    const prodPaths = config.prebuiltImage ? void 0 : config.productionPaths;
+    const workDir = config.prebuiltImage ? "/" : builtArtifact?.runtime.workdir ?? (prodPaths?.length ? "/app/production" : "/app");
     if (prodPaths?.length) {
       try {
         const rt = await ws.runtime();
@@ -2421,7 +2526,7 @@ fi`;
         );
       }
     }
-    const startCommand = builtArtifact?.runtime.startCommand || config.startCommand || "npm start";
+    const startCommand = builtArtifact?.runtime.startCommand || config.startCommand || (config.prebuiltImage ? void 0 : "npm start");
     const projectEnv = splitRuntimeEnv(config.envVars);
     if (projectEnv.dropped.length > 0) {
       onLog?.({
@@ -2438,19 +2543,31 @@ fi`;
     const workloadCmd = resolveCloudWorkloadCmd({
       startCommand,
       workdir: workDir,
-      binPathExport: builtArtifact ? "" : nodeBinPathExport(config.packageManager, [workDir, "/app"])
+      binPathExport: builtArtifact || config.prebuiltImage ? "" : nodeBinPathExport(config.packageManager, [workDir, "/app"])
     });
-    try {
-      await ws.workloads.create({
-        name: "app",
-        cmd: workloadCmd,
-        working_dir: workDir,
-        env: [...envArray, `PORT=${config.port}`],
-        restart_policy: restartPolicy,
-        max_restarts: 10
+    if (workloadCmd) {
+      try {
+        if (config.prebuiltImage) {
+          await ws.workloads.delete("app").catch(() => {
+          });
+        }
+        await ws.workloads.create({
+          name: "app",
+          cmd: workloadCmd,
+          working_dir: workDir,
+          env: [...envArray, `PORT=${config.port}`],
+          restart_policy: restartPolicy,
+          max_restarts: 10
+        });
+      } catch (err) {
+        throw new Error(`Failed to create workload: ${err instanceof Error ? err.message : err}`);
+      }
+    } else {
+      log({
+        timestamp: now2(),
+        level: "info",
+        message: "Using the prebuilt image's default command and working directory.\n"
       });
-    } catch (err) {
-      throw new Error(`Failed to create workload: ${err instanceof Error ? err.message : err}`);
     }
     let url;
     const primaryEndpoint = primaryPublicEndpoint(config);
@@ -2588,7 +2705,9 @@ fi`;
         pg = result.page;
       } catch (err) {
         if (isOutputPathError(err)) throw outputDirError();
-        throw new Error(`Failed to create static page for slug "${pageSlug}": ${safeErrorMessage(err)}`);
+        throw new Error(
+          `Failed to create static page for slug "${pageSlug}": ${safeErrorMessage(err)}`
+        );
       }
       return { ...pg, url: void 0 };
     };
@@ -2603,7 +2722,9 @@ fi`;
         });
         page = result.page;
       } catch (err) {
-        throw new Error(`Failed to redeploy static page for slug "${pageSlug}": ${safeErrorMessage(err)}`);
+        throw new Error(
+          `Failed to redeploy static page for slug "${pageSlug}": ${safeErrorMessage(err)}`
+        );
       }
     } else {
       if (existingPage) {
@@ -3222,6 +3343,7 @@ function clampShellWindow(value, fallback, min, max) {
 }
 
 export {
+  compileCloudDockerfilePlan,
   PAGE_CONTAINER_PREFIX,
   provisionCloudWorkspace,
   HostBuildForbiddenError,