@vellumai/cli 0.4.42 → 0.4.44

package/src/lib/assistant-config.ts

@@ -16,13 +16,10 @@ import { probePort } from "./port-probe.js";
  */
 export interface LocalInstanceResources {
   /**
-   * Instance-specific data root. The first local assistant uses `~` (workspace
-   * at `~/.vellum`); subsequent assistants use
-   * `~/.local/share/vellum/assistants/<name>/` (workspace at
-   * `~/.local/share/vellum/assistants/<name>/.vellum`).
-   * The daemon's `.vellum/` directory lives inside it. Equivalent to
-   * `AssistantEntry.baseDataDir` minus the trailing `/.vellum` suffix —
-   * `baseDataDir` is kept on the flat entry for legacy lockfile compat.
+   * Instance-specific data root. The first local assistant uses `~` (home
+   * directory) with default ports. Subsequent instances are placed under
+   * `~/.local/share/vellum/assistants/<name>/`.
+   * The daemon's `.vellum/` directory lives inside it.
    */
   instanceDir: string;
   /** HTTP port for the daemon runtime server */
@@ -31,10 +28,9 @@ export interface LocalInstanceResources {
   gatewayPort: number;
   /** HTTP port for the Qdrant vector store */
   qdrantPort: number;
-  /** Absolute path to the Unix domain socket for IPC */
-  socketPath: string;
   /** Absolute path to the daemon PID file */
   pidFile: string;
+  [key: string]: unknown;
 }
 
 export interface AssistantEntry {
@@ -43,8 +39,6 @@ export interface AssistantEntry {
   /** Loopback URL for same-machine health checks (e.g. `http://127.0.0.1:7831`).
    *  Avoids mDNS resolution issues when the machine checks its own gateway. */
   localUrl?: string;
-  /** @deprecated Use `resources.instanceDir` for multi-instance entries. Legacy equivalent of `join(instanceDir, ".vellum")`. */
-  baseDataDir?: string;
   bearerToken?: string;
   cloud: string;
   instanceId?: string;
@@ -57,10 +51,11 @@ export interface AssistantEntry {
   hatchedAt?: string;
   /** Per-instance resource config. Present for local entries in multi-instance setups. */
   resources?: LocalInstanceResources;
+  [key: string]: unknown;
 }
 
 interface LockfileData {
-  assistants?: AssistantEntry[];
+  assistants?: Record<string, unknown>[];
   activeAssistant?: string;
   platformBaseUrl?: string;
   [key: string]: unknown;
@@ -70,8 +65,13 @@ function getBaseDir(): string {
   return process.env.BASE_DATA_DIR?.trim() || homedir();
 }
 
+/** The lockfile always lives under the home directory. */
+function getLockfileDir(): string {
+  return process.env.VELLUM_LOCKFILE_DIR?.trim() || homedir();
+}
+
 function readLockfile(): LockfileData {
-  const base = getBaseDir();
+  const base = getLockfileDir();
   const candidates = [
     join(base, ".vellum.lock.json"),
     join(base, ".vellum.lockfile.json"),
@@ -92,18 +92,136 @@ function readLockfile(): LockfileData {
 }
 
 function writeLockfile(data: LockfileData): void {
-  const lockfilePath = join(getBaseDir(), ".vellum.lock.json");
+  const lockfilePath = join(getLockfileDir(), ".vellum.lock.json");
   writeFileSync(lockfilePath, JSON.stringify(data, null, 2) + "\n");
 }
 
+/**
+ * Try to extract a port number from a URL string (e.g. `http://localhost:7830`).
+ * Returns undefined if the URL is malformed or has no explicit port.
+ */
+function parsePortFromUrl(url: unknown): number | undefined {
+  if (typeof url !== "string") return undefined;
+  try {
+    const parsed = new URL(url);
+    const port = parseInt(parsed.port, 10);
+    return isNaN(port) ? undefined : port;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Detect and migrate legacy lockfile entries to the current format.
+ *
+ * Legacy entries stored `baseDataDir` as a top-level field. The current
+ * format nests this under `resources.instanceDir`. This function also
+ * synthesises a full `resources` object when one is missing by inferring
+ * ports from the entry's `runtimeUrl` and falling back to defaults.
+ *
+ * Returns `true` if the entry was mutated (so the caller can persist).
+ */
+export function migrateLegacyEntry(raw: Record<string, unknown>): boolean {
+  if (typeof raw.cloud === "string" && raw.cloud !== "local") {
+    return false;
+  }
+
+  let mutated = false;
+
+  // Migrate top-level `baseDataDir` → `resources.instanceDir`
+  if (typeof raw.baseDataDir === "string" && raw.baseDataDir) {
+    if (!raw.resources || typeof raw.resources !== "object") {
+      raw.resources = {};
+    }
+    const res = raw.resources as Record<string, unknown>;
+    if (!res.instanceDir) {
+      res.instanceDir = raw.baseDataDir;
+      mutated = true;
+    }
+    delete raw.baseDataDir;
+    mutated = true;
+  }
+
+  // Synthesise missing `resources` for local entries
+  if (!raw.resources || typeof raw.resources !== "object") {
+    const gatewayPort =
+      parsePortFromUrl(raw.runtimeUrl) ?? DEFAULT_GATEWAY_PORT;
+    const instanceDir = join(
+      homedir(),
+      ".local",
+      "share",
+      "vellum",
+      "assistants",
+      typeof raw.assistantId === "string" ? raw.assistantId : "default",
+    );
+    raw.resources = {
+      instanceDir,
+      daemonPort: DEFAULT_DAEMON_PORT,
+      gatewayPort,
+      qdrantPort: DEFAULT_QDRANT_PORT,
+      pidFile: join(instanceDir, ".vellum", "vellum.pid"),
+    };
+    mutated = true;
+  } else {
+    // Backfill any missing fields on an existing partial `resources` object
+    const res = raw.resources as Record<string, unknown>;
+    if (!res.instanceDir) {
+      res.instanceDir = join(
+        homedir(),
+        ".local",
+        "share",
+        "vellum",
+        "assistants",
+        typeof raw.assistantId === "string" ? raw.assistantId : "default",
+      );
+      mutated = true;
+    }
+    if (typeof res.daemonPort !== "number") {
+      res.daemonPort = DEFAULT_DAEMON_PORT;
+      mutated = true;
+    }
+    if (typeof res.gatewayPort !== "number") {
+      res.gatewayPort =
+        parsePortFromUrl(raw.runtimeUrl) ?? DEFAULT_GATEWAY_PORT;
+      mutated = true;
+    }
+    if (typeof res.qdrantPort !== "number") {
+      res.qdrantPort = DEFAULT_QDRANT_PORT;
+      mutated = true;
+    }
+    if (typeof res.pidFile !== "string") {
+      res.pidFile = join(
+        res.instanceDir as string,
+        ".vellum",
+        "vellum.pid",
+      );
+      mutated = true;
+    }
+  }
+
+  return mutated;
+}
+
 function readAssistants(): AssistantEntry[] {
   const data = readLockfile();
   const entries = data.assistants;
   if (!Array.isArray(entries)) {
     return [];
   }
+
+  let migrated = false;
+  for (const entry of entries) {
+    if (migrateLegacyEntry(entry)) {
+      migrated = true;
+    }
+  }
+
+  if (migrated) {
+    writeLockfile(data);
+  }
+
   return entries.filter(
-    (e) =>
+    (e): e is AssistantEntry =>
       typeof e.assistantId === "string" && typeof e.runtimeUrl === "string",
   );
 }
@@ -135,12 +253,17 @@ export function findAssistantByName(name: string): AssistantEntry | null {
 export function removeAssistantEntry(assistantId: string): void {
   const data = readLockfile();
   const entries = (data.assistants ?? []).filter(
-    (e: AssistantEntry) => e.assistantId !== assistantId,
+    (e) => e.assistantId !== assistantId,
   );
   data.assistants = entries;
-  // Clear active assistant if it matches the removed entry
+  // Reassign active assistant if it matches the removed entry
   if (data.activeAssistant === assistantId) {
-    delete data.activeAssistant;
+    const remaining = entries[0];
+    if (remaining) {
+      data.activeAssistant = String(remaining.assistantId);
+    } else {
+      delete data.activeAssistant;
+    }
   }
   writeLockfile(data);
 }
@@ -228,17 +351,26 @@ async function findAvailablePort(
 
 /**
  * Allocate an isolated set of resources for a named local instance.
- * The first local assistant gets `instanceDir = ~` with default ports (same as
- * legacy single-instance layout). Subsequent assistants are placed under
+ * The first local assistant uses the home directory with default ports.
+ * Subsequent assistants are placed under
  * `~/.local/share/vellum/assistants/<name>/` with scanned ports.
  */
 export async function allocateLocalResources(
   instanceName: string,
 ): Promise<LocalInstanceResources> {
-  // First local assistant gets the home directory — identical to legacy layout.
+  // First local assistant gets the home directory with default ports.
   const existingLocals = loadAllAssistants().filter((e) => e.cloud === "local");
   if (existingLocals.length === 0) {
-    return defaultLocalResources();
+    const home = homedir();
+    const vellumDir = join(home, ".vellum");
+    mkdirSync(vellumDir, { recursive: true });
+    return {
+      instanceDir: home,
+      daemonPort: DEFAULT_DAEMON_PORT,
+      gatewayPort: DEFAULT_GATEWAY_PORT,
+      qdrantPort: DEFAULT_QDRANT_PORT,
+      pidFile: join(vellumDir, "vellum.pid"),
+    };
   }
 
   const instanceDir = join(
@@ -263,13 +395,6 @@ export async function allocateLocalResources(
         entry.resources.gatewayPort,
         entry.resources.qdrantPort,
       );
-    } else {
-      // Legacy entries without resources use the default ports
-      reservedPorts.push(
-        DEFAULT_DAEMON_PORT,
-        DEFAULT_GATEWAY_PORT,
-        DEFAULT_QDRANT_PORT,
-      );
     }
   }
 
@@ -294,42 +419,10 @@ export async function allocateLocalResources(
     daemonPort,
     gatewayPort,
     qdrantPort,
-    socketPath: join(instanceDir, ".vellum", "vellum.sock"),
     pidFile: join(instanceDir, ".vellum", "vellum.pid"),
   };
 }
 
-/**
- * Return default resources representing the legacy single-instance layout.
- * Used to normalize existing lockfile entries so callers can treat all local
- * entries uniformly.
- */
-export function defaultLocalResources(): LocalInstanceResources {
-  const vellumDir = join(homedir(), ".vellum");
-  return {
-    instanceDir: homedir(),
-    daemonPort: DEFAULT_DAEMON_PORT,
-    gatewayPort: DEFAULT_GATEWAY_PORT,
-    qdrantPort: DEFAULT_QDRANT_PORT,
-    socketPath: join(vellumDir, "vellum.sock"),
-    pidFile: join(vellumDir, "vellum.pid"),
-  };
-}
-
-/**
- * Normalize existing lockfile entries so local entries include resource fields.
- * Remote entries are left untouched. Returns a new array (does not mutate input).
- */
-export function normalizeExistingEntryResources(
-  entries: AssistantEntry[],
-): AssistantEntry[] {
-  return entries.map((entry) => {
-    if (entry.cloud !== "local") return entry;
-    if (entry.resources) return entry;
-    return { ...entry, resources: defaultLocalResources() };
-  });
-}
-
 /**
  * Read the assistant config file and sync client-relevant values to the
  * lockfile. This lets external tools (e.g. vel) discover the platform URL

package/src/lib/aws.ts

@@ -5,7 +5,7 @@ import { join } from "path";
 
 import { buildStartupScript, watchHatching } from "../commands/hatch";
 import type { PollResult } from "../commands/hatch";
-import { saveAssistantEntry } from "./assistant-config";
+import { saveAssistantEntry, setActiveAssistant } from "./assistant-config";
 import type { AssistantEntry } from "./assistant-config";
 import { GATEWAY_PORT } from "./constants";
 import type { Species } from "./constants";
@@ -370,6 +370,28 @@ async function pollAwsInstance(
   }
 }
 
+async function fetchRemoteBearerToken(
+  ip: string,
+  keyPath: string,
+): Promise<string | null> {
+  try {
+    const remoteCmd =
+      'cat ~/.vellum.lock.json 2>/dev/null || cat ~/.vellum.lockfile.json 2>/dev/null || echo "{}"';
+    const output = await awsSshExec(ip, keyPath, remoteCmd);
+    const data = JSON.parse(output.trim());
+    const assistants = data.assistants;
+    if (Array.isArray(assistants) && assistants.length > 0) {
+      const token = assistants[0].bearerToken;
+      if (typeof token === "string" && token) {
+        return token;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export async function hatchAws(
   species: Species,
   detached: boolean,
@@ -500,6 +522,7 @@ export async function hatchAws(
       hatchedAt: new Date().toISOString(),
     };
     saveAssistantEntry(awsEntry);
+    setActiveAssistant(instanceName);
 
     if (detached) {
       console.log("\u{1F680} Startup script is running on the instance...");
@@ -535,6 +558,12 @@ export async function hatchAws(
           }
           process.exit(1);
         }
+
+        const remoteBearerToken = await fetchRemoteBearerToken(ip, keyPath);
+        if (remoteBearerToken) {
+          awsEntry.bearerToken = remoteBearerToken;
+          saveAssistantEntry(awsEntry);
+        }
       } else {
         console.log(
           "\u26a0\ufe0f  No external IP available for monitoring. Instance is still running.",

package/src/lib/docker.ts

@@ -0,0 +1,321 @@
+import { spawn as nodeSpawn } from "child_process";
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+
+import { saveAssistantEntry, setActiveAssistant } from "./assistant-config";
+import type { AssistantEntry } from "./assistant-config";
+import { DEFAULT_GATEWAY_PORT } from "./constants";
+import type { Species } from "./constants";
+import { discoverPublicUrl } from "./local";
+import { generateRandomSuffix } from "./random-name";
+import { exec, execOutput } from "./step-runner";
+import { closeLogFile, openLogFile, resetLogFile, writeToLogFile } from "./xdg-log";
+
+const _require = createRequire(import.meta.url);
+
+interface DockerRoot {
+  /** Directory to use as the Docker build context */
+  root: string;
+  /** Relative path from root to the directory containing the Dockerfiles */
+  dockerfileDir: string;
+}
+
+/**
+ * Locate the directory containing the Dockerfile. In the source tree the
+ * Dockerfiles live under `meta/`, but when installed as an npm package they
+ * are at the package root.
+ */
+function findDockerRoot(): DockerRoot {
+  // Source tree: cli/src/lib/ -> repo root (Dockerfiles in meta/)
+  const sourceTreeRoot = join(import.meta.dir, "..", "..", "..");
+  if (existsSync(join(sourceTreeRoot, "meta", "Dockerfile"))) {
+    return { root: sourceTreeRoot, dockerfileDir: "meta" };
+  }
+
+  // bunx layout: @vellumai/cli/src/lib/ -> ../../../.. -> node_modules -> vellum/
+  const bunxRoot = join(import.meta.dir, "..", "..", "..", "..", "vellum");
+  if (existsSync(join(bunxRoot, "Dockerfile"))) {
+    return { root: bunxRoot, dockerfileDir: "." };
+  }
+
+  // Walk up from cwd looking for meta/Dockerfile (source checkout)
+  let dir = process.cwd();
+  while (true) {
+    if (existsSync(join(dir, "meta", "Dockerfile"))) {
+      return { root: dir, dockerfileDir: "meta" };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Fall back to Node module resolution for the `vellum` package
+  try {
+    const vellumPkgPath = _require.resolve("vellum/package.json");
+    const vellumDir = dirname(vellumPkgPath);
+    if (existsSync(join(vellumDir, "Dockerfile"))) {
+      return { root: vellumDir, dockerfileDir: "." };
+    }
+  } catch {
+    // resolution failed
+  }
+
+  throw new Error(
+    "Could not find Dockerfile. Run this command from within the " +
+      "vellum-assistant repository, or ensure the vellum package is installed.",
+  );
+}
+
+/**
+ * Creates a line-buffered output prefixer that prepends `[docker]` to each
+ * line from the container's stdout/stderr. Calls `onLine` for each complete
+ * line so the caller can detect sentinel output (e.g. hatch completion).
+ */
+function createLinePrefixer(
+  stream: NodeJS.WritableStream,
+  onLine?: (line: string) => void,
+): { write(data: Buffer): void; flush(): void } {
+  let remainder = "";
+  return {
+    write(data: Buffer) {
+      const text = remainder + data.toString();
+      const lines = text.split("\n");
+      remainder = lines.pop() ?? "";
+      for (const line of lines) {
+        stream.write(`   [docker] ${line}\n`);
+        onLine?.(line);
+      }
+    },
+    flush() {
+      if (remainder) {
+        stream.write(`   [docker] ${remainder}\n`);
+        onLine?.(remainder);
+        remainder = "";
+      }
+    },
+  };
+}
+
+async function fetchRemoteBearerToken(
+  containerName: string,
+): Promise<string | null> {
+  try {
+    const remoteCmd =
+      'cat ~/.vellum.lock.json 2>/dev/null || cat ~/.vellum.lockfile.json 2>/dev/null || echo "{}"';
+    const output = await execOutput("docker", [
+      "exec",
+      containerName,
+      "sh",
+      "-c",
+      remoteCmd,
+    ]);
+    const data = JSON.parse(output.trim());
+    const assistants = data.assistants;
+    if (Array.isArray(assistants) && assistants.length > 0) {
+      const token = assistants[0].bearerToken;
+      if (typeof token === "string" && token) {
+        return token;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function retireDocker(name: string): Promise<void> {
+  console.log(`\u{1F5D1}\ufe0f  Stopping Docker container '${name}'...\n`);
+
+  try {
+    await exec("docker", ["stop", name]);
+  } catch (error) {
+    console.warn(
+      `\u26a0\ufe0f  Failed to stop container: ${error instanceof Error ? error.message : error}`,
+    );
+  }
+
+  try {
+    await exec("docker", ["rm", name]);
+  } catch (error) {
+    console.warn(
+      `\u26a0\ufe0f  Failed to remove container: ${error instanceof Error ? error.message : error}`,
+    );
+  }
+
+  console.log(`\u2705 Docker instance retired.`);
+}
+
+export async function hatchDocker(
+  species: Species,
+  detached: boolean,
+  name: string | null,
+  watch: boolean,
+): Promise<void> {
+  const { root: repoRoot, dockerfileDir } = findDockerRoot();
+  const instanceName = name ?? `${species}-${generateRandomSuffix()}`;
+  const dockerfileName = watch ? "Dockerfile.development" : "Dockerfile";
+  const dockerfile = join(dockerfileDir, dockerfileName);
+  const dockerfilePath = join(repoRoot, dockerfile);
+
+  if (!existsSync(dockerfilePath)) {
+    console.error(`Error: ${dockerfile} not found at ${dockerfilePath}`);
+    process.exit(1);
+  }
+
+  resetLogFile("hatch.log");
+
+  console.log(`🥚 Hatching Docker assistant: ${instanceName}`);
+  console.log(`   Species: ${species}`);
+  console.log(`   Dockerfile: ${dockerfile}`);
+  if (watch) {
+    console.log(`   Mode: development (watch)`);
+  }
+  console.log("");
+
+  const imageTag = `vellum-assistant:${instanceName}`;
+  const logFd = openLogFile("hatch.log");
+  console.log("🔨 Building Docker image...");
+  try {
+    await exec("docker", ["build", "-f", dockerfile, "-t", imageTag, "."], {
+      cwd: repoRoot,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    writeToLogFile(logFd, `[docker-build] ${new Date().toISOString()} ERROR\n${message}\n`);
+    closeLogFile(logFd);
+    throw err;
+  }
+  closeLogFile(logFd);
+  console.log("✅ Docker image built\n");
+
+  const gatewayPort = DEFAULT_GATEWAY_PORT;
+  const runArgs: string[] = [
+    "run",
+    "--init",
+    "--name",
+    instanceName,
+    "-p",
+    `${gatewayPort}:${gatewayPort}`,
+  ];
+
+  // Pass through environment variables the assistant needs
+  for (const envVar of [
+    "ANTHROPIC_API_KEY",
+    "GATEWAY_RUNTIME_PROXY_ENABLED",
+    "RUNTIME_PROXY_BEARER_TOKEN",
+    "VELLUM_ASSISTANT_PLATFORM_URL",
+  ]) {
+    if (process.env[envVar]) {
+      runArgs.push("-e", `${envVar}=${process.env[envVar]}`);
+    }
+  }
+
+  // Pass the instance name so the inner hatch uses the same assistant ID
+  // instead of generating a new random one.
+  runArgs.push("-e", `VELLUM_ASSISTANT_NAME=${instanceName}`);
+
+  // Mount source volumes in watch mode for hot reloading
+  if (watch) {
+    runArgs.push(
+      "-v",
+      `${join(repoRoot, "assistant", "src")}:/app/assistant/src`,
+      "-v",
+      `${join(repoRoot, "gateway", "src")}:/app/gateway/src`,
+      "-v",
+      `${join(repoRoot, "cli", "src")}:/app/cli/src`,
+    );
+  }
+
+  const publicUrl = await discoverPublicUrl(gatewayPort);
+  const runtimeUrl = publicUrl || `http://localhost:${gatewayPort}`;
+  const dockerEntry: AssistantEntry = {
+    assistantId: instanceName,
+    runtimeUrl,
+    cloud: "docker",
+    species,
+    hatchedAt: new Date().toISOString(),
+  };
+  saveAssistantEntry(dockerEntry);
+  setActiveAssistant(instanceName);
+
+  // The Dockerfiles already define a CMD that runs `vellum hatch --keep-alive`.
+  // Only override CMD when a non-default species is specified, since that
+  // requires an extra argument the Dockerfile doesn't include.
+  const containerCmd: string[] =
+    species !== "vellum"
+      ? ["vellum", "hatch", species, ...(watch ? ["--watch"] : []), "--keep-alive"]
+      : [];
+
+  // Always start the container detached so it keeps running after the CLI exits.
+  runArgs.push("-d");
+  console.log("🚀 Starting Docker container...");
+  await exec("docker", [...runArgs, imageTag, ...containerCmd], { cwd: repoRoot });
+
+  if (detached) {
+    console.log("\n✅ Docker assistant hatched!\n");
+    console.log("Instance details:");
+    console.log(`  Name: ${instanceName}`);
+    console.log(`  Runtime: ${runtimeUrl}`);
+    console.log(`  Container: ${instanceName}`);
+    console.log("");
+    console.log(`Stop with: docker stop ${instanceName}`);
+  } else {
+    console.log(`  Container: ${instanceName}`);
+    console.log(`  Runtime: ${runtimeUrl}`);
+    console.log("");
+
+    // Tail container logs until the inner hatch completes, then exit and
+    // leave the container running in the background.
+    await new Promise<void>((resolve, reject) => {
+      const child = nodeSpawn("docker", ["logs", "-f", instanceName], {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      const handleLine = (line: string): void => {
+        if (line.includes("Local assistant hatched!")) {
+          process.nextTick(async () => {
+            const remoteBearerToken =
+              await fetchRemoteBearerToken(instanceName);
+            if (remoteBearerToken) {
+              dockerEntry.bearerToken = remoteBearerToken;
+              saveAssistantEntry(dockerEntry);
+            }
+
+            console.log("");
+            console.log(`\u2705 Docker container is up and running!`);
+            console.log(`   Name: ${instanceName}`);
+            console.log(`   Runtime: ${runtimeUrl}`);
+            console.log("");
+            child.kill();
+            resolve();
+          });
+        }
+      };
+
+      const stdoutPrefixer = createLinePrefixer(process.stdout, handleLine);
+      const stderrPrefixer = createLinePrefixer(process.stderr, handleLine);
+
+      child.stdout?.on("data", (data: Buffer) => stdoutPrefixer.write(data));
+      child.stderr?.on("data", (data: Buffer) => stderrPrefixer.write(data));
+      child.stdout?.on("end", () => stdoutPrefixer.flush());
+      child.stderr?.on("end", () => stderrPrefixer.flush());
+
+      child.on("close", (code) => {
+        // The log tail may exit if the container stops before the sentinel
+        // is seen, or we killed it after detecting the sentinel.
+        if (code === 0 || code === null || code === 130 || code === 137 || code === 143) {
+          resolve();
+        } else {
+          reject(new Error(`Docker container exited with code ${code}`));
+        }
+      });
+      child.on("error", reject);
+
+      process.on("SIGINT", () => {
+        child.kill();
+        resolve();
+      });
+    });
+  }
+}