@outerlayer/cli 0.1.1 → 0.4.0

package/dist/chunk-774HEQL6.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { RecipeError } from './chunk-QOZKPLVJ.js';
+import { spawn } from 'child_process';
+import { existsSync, mkdirSync, createWriteStream, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { createRequire as createRequire$1 } from 'module';
+import { fileURLToPath } from 'url';
+
+createRequire(import.meta.url);
+var PACKAGE = "@devcontainers/cli";
+function buildRootFromDist(moduleDir = dirname(fileURLToPath(import.meta.url))) {
+  try {
+    const info = JSON.parse(readFileSync(join(moduleDir, "build-info.json"), "utf8"));
+    return typeof info.root === "string" ? info.root : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveDevcontainerCli(opts = {}) {
+  const resolve = opts.resolve ?? createRequire$1(import.meta.url).resolve;
+  try {
+    const bin = join(dirname(resolve(`${PACKAGE}/package.json`)), "devcontainer.js");
+    if (existsSync(bin)) return { command: process.execPath, args: [bin] };
+  } catch {
+  }
+  const buildRoot = opts.buildRoot ?? buildRootFromDist();
+  const fallback = buildRoot === void 0 ? void 0 : join(buildRoot, "node_modules", PACKAGE);
+  if (fallback !== void 0 && existsSync(join(fallback, "devcontainer.js"))) {
+    return { command: process.execPath, args: [join(fallback, "devcontainer.js")] };
+  }
+  throw new RecipeError(
+    "devcontainer_cli_missing",
+    `the devcontainer CLI is not installed: looked beside this package and in ${fallback ?? "the checkout this build came from (unknown)"}. Run yarn install in that checkout.`
+  );
+}
+function devcontainerBuildInvocation(cli, req) {
+  return {
+    command: cli.command,
+    args: [
+      ...cli.args,
+      "build",
+      "--workspace-folder",
+      req.workspace,
+      "--config",
+      req.config,
+      "--image-name",
+      req.imageName,
+      ...Object.entries(req.labels).flatMap(([key, value]) => ["--label", `${key}=${value}`]),
+      "--log-format",
+      "text"
+    ]
+  };
+}
+
+// src/runner/image/docker.ts
+var CHILD_ENVIRONMENT_NAMES = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "TMPDIR",
+  "LANG",
+  "LC_ALL",
+  "DOCKER_HOST",
+  "DOCKER_CONFIG",
+  "DOCKER_CONTEXT",
+  "DOCKER_CERT_PATH",
+  "DOCKER_TLS_VERIFY",
+  "DOCKER_API_VERSION",
+  "DOCKER_BUILDKIT",
+  "XDG_RUNTIME_DIR",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_CACHE_HOME",
+  "XDG_STATE_HOME"
+];
+function childEnvironment(base) {
+  const env = {};
+  for (const name of CHILD_ENVIRONMENT_NAMES) {
+    const value = base[name];
+    if (value !== void 0) env[name] = value;
+  }
+  return env;
+}
+var spawnRun = (command, args, opts = {}) => new Promise((resolve) => {
+  let log;
+  if (opts.logPath !== void 0) {
+    mkdirSync(dirname(opts.logPath), { recursive: true });
+    log = createWriteStream(opts.logPath, { flags: "a" });
+  }
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+  const finish = (status, extra = "") => {
+    if (settled) return;
+    settled = true;
+    const result = { status, stdout, stderr: stderr + extra };
+    if (log === void 0) {
+      resolve(result);
+      return;
+    }
+    if (extra) log.write(extra);
+    log.end(() => resolve(result));
+  };
+  const child = spawn(command, args, {
+    env: { ...childEnvironment(process.env), ...opts.env },
+    stdio: [opts.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+  });
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+    log?.write(chunk);
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+    log?.write(chunk);
+  });
+  child.on("error", (err) => finish(127, `${command}: ${err.message}
+`));
+  child.on("close", (code, signal) => finish(code ?? (signal ? 128 : 1)));
+  if (opts.input !== void 0) {
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(opts.input);
+  }
+});
+function toInfo(row) {
+  return { id: row.Id, createdAt: row.Created, labels: row.Config?.Labels ?? {} };
+}
+var lines = (text) => [...new Set(text.split("\n").map((l) => l.trim()).filter(Boolean))];
+function createDockerHost(deps = {}) {
+  const run = deps.run ?? spawnRun;
+  const cli = deps.cli ?? resolveDevcontainerCli;
+  const inspectMany = async (refs) => {
+    const result = await run("docker", ["image", "inspect", ...refs]);
+    return result.status === 0 ? JSON.parse(result.stdout).map(toInfo) : [];
+  };
+  return {
+    async inspect(ref) {
+      return (await inspectMany([ref]))[0] ?? null;
+    },
+    async list(repository) {
+      const ids = await run("docker", [
+        "image",
+        "ls",
+        "--all",
+        "--no-trunc",
+        "--quiet",
+        "--filter",
+        `label=ai.outerlayer.repository=${repository}`
+      ]);
+      const found = lines(ids.stdout);
+      return found.length === 0 ? [] : inspectMany(found);
+    },
+    async inUse() {
+      const containers = lines((await run("docker", ["ps", "--all", "--no-trunc", "--quiet"])).stdout);
+      if (containers.length === 0) return [];
+      return lines((await run("docker", ["inspect", "--format", "{{.Image}}", ...containers])).stdout);
+    },
+    async buildDockerfile(req) {
+      const labels = Object.entries(req.labels).flatMap(([key, value]) => ["--label", `${key}=${value}`]);
+      const result = await run("docker", ["build", "--tag", req.tag, ...labels, "--file", "-", req.context], {
+        logPath: req.logPath,
+        input: req.dockerfile
+      });
+      return result.status;
+    },
+    async devcontainerBuild(req) {
+      const { command, args } = devcontainerBuildInvocation(cli(), req);
+      return (await run(command, args, { logPath: req.logPath })).status;
+    },
+    async remove(id) {
+      const result = await run("docker", ["rmi", id]);
+      if (result.status !== 0) throw new Error(result.stderr.trim() || `docker rmi ${id} exited ${result.status}`);
+    }
+  };
+}
+
+export { childEnvironment, createDockerHost, resolveDevcontainerCli, spawnRun };