@emulates/docker 0.0.0-stage → 0.1.1

package/dist/chunk-ZO7PO2NA.js

@@ -0,0 +1,629 @@
+import {
+  DockerInputError,
+  annotateResponse,
+  booleanQuery,
+  createRuntime,
+  isRunning,
+  jsonRes
+} from "./chunk-NSXRVOHP.js";
+
+// src/attach.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { STATUS_CODES } from "node:http";
+
+// src/streams.ts
+var limit = (value, name) => {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 16 * 1024 * 1024)
+    throw new RangeError(`${name} must be 1..16777216`);
+  return value;
+};
+var createAttachStreams = (options = {}) => {
+  const chunkBytes = limit(options.frameChunkBytes ?? 64 * 1024, "frameChunkBytes");
+  const maxQueued = limit(options.maxQueuedBytes ?? 1024 * 1024, "maxQueuedBytes");
+  const maxStdin = limit(options.maxStdinBytes ?? 1024 * 1024, "maxStdinBytes");
+  const sessions = /* @__PURE__ */ new Set();
+  let sequence = 0;
+  const connect = (selection, socket, runtime) => {
+    const { api, containerId, namespace, branch } = selection;
+    let closed = false, outputClosed = false, retired = false, inputEnded = false, queuedBytes = 0, inputSize = 0;
+    let input = [];
+    let tail = Promise.resolve();
+    let releaseReady = (_ready) => {
+    };
+    const ready = new Promise((resolve) => {
+      releaseReady = resolve;
+    });
+    const valid = () => !closed && api.generation === selection.generation;
+    const closeInput = () => {
+      inputEnded = true;
+      if (!valid() || retired || !selection.stdin || !selection.stdinOnce) return;
+      const c = api.state.containers.get(containerId);
+      if (c && !c.stdinClosed) {
+        api.state.containers.update(containerId, { ...c, stdinClosed: true });
+        runtime.checkpoint(namespace, branch);
+      }
+    };
+    let detachInvalidation = () => {
+    }, detachExit = () => {
+    };
+    const release = () => {
+      if (closed) return;
+      closed = true;
+      outputClosed = true;
+      releaseReady(false);
+      sessions.delete(handle);
+      detachInvalidation();
+      detachExit();
+      socket.off("data", onData);
+      socket.off("end", onEnd);
+    };
+    const cancel = () => {
+      closeInput();
+      release();
+      input = [];
+      inputSize = 0;
+      socket.destroy();
+    };
+    const send = (bytes) => new Promise((resolve, reject) => {
+      const close = () => {
+        socket.off("close", close);
+        reject(new Error("Attachment closed"));
+      };
+      if (!valid() || socket.destroyed) {
+        close();
+        return;
+      }
+      socket.once("close", close);
+      socket.write(bytes, (error) => {
+        socket.off("close", close);
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+    const onData = (chunk) => {
+      if (!valid() || retired) return;
+      if (!selection.stdin || api.state.containers.get(containerId)?.stdinClosed) return;
+      if (inputSize + chunk.length > maxStdin) {
+        cancel();
+        return;
+      }
+      input.push(Buffer.from(chunk));
+      inputSize += chunk.length;
+    };
+    const onEnd = () => {
+      closeInput();
+      if (selection.stdin && !selection.stdinOnce) void handle.end().catch(cancel);
+    };
+    const finish = async () => {
+      await tail;
+      if (valid() && !socket.destroyed) socket.end();
+    };
+    const handle = {
+      id: ++sequence,
+      containerId,
+      namespace,
+      branch,
+      get closed() {
+        return closed;
+      },
+      get stdinClosed() {
+        return inputEnded || api.state.containers.get(containerId)?.stdinClosed === true;
+      },
+      get queuedBytes() {
+        return queuedBytes;
+      },
+      async write(channel, data) {
+        if (!valid() || outputClosed) throw new Error("Attachment closed");
+        if (channel !== "stdout" && channel !== "stderr")
+          throw new TypeError("Unknown output channel");
+        if (!selection[channel]) return;
+        const size = data.byteLength + 8;
+        if (size + queuedBytes > maxQueued)
+          throw new RangeError("Attachment output queue limit exceeded");
+        const frame = Buffer.allocUnsafe(size);
+        frame[0] = channel === "stdout" ? 1 : 2;
+        frame.fill(0, 1, 4);
+        frame.writeUInt32BE(data.byteLength, 4);
+        frame.set(data, 8);
+        queuedBytes += size;
+        const result = tail.then(async () => {
+          if (!await ready || !valid()) throw new Error("Attachment closed");
+          for (let at = 0; at < frame.length; at += chunkBytes)
+            await send(frame.subarray(at, at + chunkBytes));
+        });
+        tail = result.catch(() => {
+        });
+        try {
+          await result;
+        } finally {
+          queuedBytes -= size;
+        }
+      },
+      takeStdin() {
+        const result = Buffer.concat(input, inputSize);
+        input = [];
+        inputSize = 0;
+        return result;
+      },
+      async end() {
+        if (!valid() || outputClosed) return;
+        outputClosed = true;
+        closeInput();
+        const c = api.state.containers.get(containerId);
+        if (selection.stdinOnce && c && isRunning(c)) return;
+        await finish();
+      },
+      cancel
+    };
+    socket.once("close", () => {
+      if (valid()) closeInput();
+      release();
+    });
+    detachInvalidation = api.onInvalidate(cancel);
+    detachExit = api.lifecycle.onExit((id) => {
+      if (id === containerId) {
+        retired = true;
+        input = [];
+        inputSize = 0;
+        inputEnded = true;
+        outputClosed = true;
+        void finish().catch(cancel);
+      }
+    });
+    sessions.add(handle);
+    if (!valid()) {
+      cancel();
+    }
+    return {
+      handle,
+      start(head) {
+        if (!valid()) return;
+        socket.on("data", onData);
+        socket.once("end", onEnd);
+        if (head.length) onData(head);
+        releaseReady(true);
+        socket.resume();
+        if (!selection.stdin && !selection.stdout && !selection.stderr)
+          void handle.end().catch(cancel);
+      },
+      cancel
+    };
+  };
+  return { connect, list: () => [...sessions] };
+};
+
+// src/attach.ts
+var header = Buffer.from(
+  "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.multiplexed-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n\r\n"
+);
+var createAttachHandshake = (options = {}, streamOptions = {}) => {
+  const streams = createAttachStreams(streamOptions);
+  const chunkBytes = options.chunkBytes ?? header.length;
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1 || chunkBytes > 4096)
+    throw new RangeError("attach chunkBytes must be 1..4096");
+  if ((options.initialStreamBytes?.byteLength ?? 0) > 1024 * 1024)
+    throw new RangeError("initialStreamBytes exceeds 1 MiB");
+  const first = Buffer.from(options.initialStreamBytes ?? []);
+  const admission = new AsyncLocalStorage();
+  const prepare = (api, request) => {
+    const context = admission.getStore();
+    if (!context) return jsonRes(501, { message: "Emulates: attach requires Node HTTP upgrade" });
+    const url = new URL(request.url);
+    if (!booleanQuery(url, "stream") || booleanQuery(url, "logs") || url.searchParams.has("detachKeys") || [...url.searchParams.keys()].some(
+      (key) => !["stream", "logs", "stdin", "stdout", "stderr"].includes(key)
+    ))
+      return jsonRes(501, { message: "Emulates: attach mode is not implemented" });
+    const match = /^\/containers\/([^/]+)\/attach$/.exec(url.pathname);
+    if (!match?.[1]) return jsonRes(404, { message: "page not found" });
+    let name;
+    try {
+      name = decodeURIComponent(match[1]);
+    } catch {
+      return jsonRes(400, { message: "invalid container name encoding" });
+    }
+    try {
+      const c = api.state.find(name);
+      if (c.status === "paused")
+        throw new DockerInputError(
+          409,
+          `container ${name} is paused, unpause the container before attach`
+        );
+      if (c.status === "restarting")
+        throw new DockerInputError(
+          409,
+          `container ${name} is restarting, wait until the container is running`
+        );
+      if (c.config?.Tty === true)
+        return jsonRes(501, { message: "Emulates: TTY attach is not implemented" });
+      context.selection = {
+        api,
+        generation: api.generation,
+        containerId: c.id,
+        namespace: request.headers.get("x-emulates-namespace") ?? "default",
+        branch: request.headers.get("x-emulates-branch") ?? "main",
+        stdin: booleanQuery(url, "stdin") && c.config?.OpenStdin === true,
+        stdinOnce: c.config?.StdinOnce === true,
+        stdout: booleanQuery(url, "stdout"),
+        stderr: booleanQuery(url, "stderr")
+      };
+      return annotateResponse(new Response(null), { wireStatus: 101, ids: { containerId: c.id } });
+    } catch (error) {
+      if (error instanceof DockerInputError)
+        return new Response(`${error.message}\r
+`, {
+          status: error.status,
+          headers: { "content-type": "application/vnd.docker.raw-stream" }
+        });
+      throw error;
+    }
+  };
+  const write = (socket, bytes) => new Promise((resolve) => {
+    const finish = (ok) => {
+      socket.off("close", closed);
+      resolve(ok);
+    };
+    const closed = () => finish(false);
+    socket.once("close", closed);
+    if (socket.destroyed) {
+      finish(false);
+      return;
+    }
+    socket.write(bytes, (error) => finish(!error));
+  });
+  const upgrade = async (runtime, req, socket, head) => {
+    socket.on("error", () => socket.destroy());
+    socket.pause();
+    try {
+      if (req.method !== "POST" || req.headers.upgrade?.toLowerCase() !== "tcp" || !req.headers.connection?.toLowerCase().split(/\s*,\s*/).includes("upgrade") || Number(req.headers["content-length"] ?? 0) !== 0 || req.headers["transfer-encoding"] !== void 0) {
+        await write(
+          socket,
+          Buffer.from(
+            "HTTP/1.1 501 Not Implemented\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"
+          )
+        );
+        socket.end();
+        return;
+      }
+      const target = new URL((req.url ?? "/").replace(/^\/+/, "/"), "http://docker.mock");
+      if (!/^(?:\/__admin\/ns\/[^/]+)?(?:\/v[0-9]+\.[0-9]+)?\/containers\/[^/]+\/attach$/.test(
+        target.pathname
+      )) {
+        await write(
+          socket,
+          Buffer.from("HTTP/1.1 404 Not Found\r\nConnection: close\r\nContent-Length: 0\r\n\r\n")
+        );
+        socket.end();
+        return;
+      }
+      const headers = new Headers();
+      for (let i = 0; i < req.rawHeaders.length; i += 2) {
+        const name = req.rawHeaders[i], value = req.rawHeaders[i + 1];
+        if (name && value !== void 0) headers.append(name, value);
+      }
+      const request = new Request(
+        new URL((req.url ?? "/").replace(/^\/+/, "/"), "http://docker.mock"),
+        { method: "POST", headers }
+      );
+      const context = {};
+      const response = await admission.run(context, () => runtime.fetch(request));
+      if (socket.destroyed) return;
+      if (!context.selection || response.status !== 200) {
+        const body = Buffer.from(await response.arrayBuffer());
+        const type = response.headers.get("content-type") ?? "application/json";
+        await write(
+          socket,
+          Buffer.concat([
+            Buffer.from(
+              `HTTP/1.1 ${response.status} ${STATUS_CODES[response.status] ?? "Error"}\r
+Content-Type: ${type}\r
+Connection: close\r
+Content-Length: ${body.length}\r
+\r
+`
+            ),
+            body
+          ])
+        );
+        socket.end();
+        return;
+      }
+      const session = streams.connect(context.selection, socket, runtime);
+      for (let offset = 0; offset < header.length; offset += chunkBytes) {
+        const end = Math.min(offset + chunkBytes, header.length);
+        const chunk = header.subarray(offset, end);
+        if (!await write(socket, end === header.length ? Buffer.concat([chunk, first]) : chunk))
+          return;
+        if (end < header.length) await new Promise((resolve) => setImmediate(resolve));
+      }
+      session.start(head);
+    } catch {
+      socket.destroy();
+    }
+  };
+  return { prepare, upgrade, attachments: streams.list };
+};
+
+// src/transport.ts
+import { lstat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { isAbsolute } from "node:path";
+var positive = (value, name) => {
+  if (!Number.isSafeInteger(value) || value <= 0)
+    throw new RangeError(`${name} must be a positive integer`);
+  return value;
+};
+var listenDocker = async (runtime, options, upgrade) => {
+  const maxBody = positive(options.maxBodyBytes ?? 1024 * 1024, "maxBodyBytes");
+  const bodyTimeout = positive(options.bodyTimeoutMs ?? 3e4, "bodyTimeoutMs");
+  const maxConnections = positive(options.maxConnections ?? 128, "maxConnections");
+  const path = options.socketPath;
+  if (path !== void 0) {
+    if (!isAbsolute(path) || path.includes("\0") || Buffer.byteLength(path) > 103)
+      throw new Error("socketPath must be an absolute Unix path of at most 103 bytes");
+    if (options.port !== void 0 || options.host !== void 0)
+      throw new Error("socketPath cannot be combined with port or host");
+    const existing = await lstat(path).then(
+      () => true,
+      (error) => {
+        if (error.code === "ENOENT") return false;
+        throw error;
+      }
+    );
+    if (existing) throw new Error("Refusing existing socketPath");
+  }
+  const sockets = /* @__PURE__ */ new Set();
+  const handle = async (req, res) => {
+    const abort = new AbortController();
+    const onClose = () => {
+      if (!res.writableFinished) abort.abort();
+    };
+    res.once("close", onClose);
+    const reject = (status) => {
+      res.writeHead(status, { "content-type": "application/json", connection: "close" });
+      res.end(JSON.stringify({ message: `Emulates transport rejected request (${status})` }));
+    };
+    try {
+      if (Number(req.headers["content-length"]) > maxBody) {
+        reject(413);
+        return;
+      }
+      const body = await new Promise((resolve, rejectBody) => {
+        const chunks = [];
+        let size = 0;
+        const cleanup = () => {
+          clearTimeout(timer);
+          req.off("data", data);
+          req.off("end", end);
+          req.off("error", error);
+          abort.signal.removeEventListener("abort", canceled);
+        };
+        const canceled = () => {
+          cleanup();
+          rejectBody(new Error("Request disconnected"));
+        };
+        const error = (e) => {
+          cleanup();
+          rejectBody(e);
+        };
+        const end = () => {
+          cleanup();
+          resolve(Buffer.concat(chunks, size));
+        };
+        const data = (chunk) => {
+          size += chunk.length;
+          if (size > maxBody) {
+            cleanup();
+            req.pause();
+            reject(413);
+            resolve(void 0);
+            return;
+          }
+          chunks.push(chunk);
+        };
+        const timer = setTimeout(() => {
+          cleanup();
+          req.pause();
+          reject(408);
+          resolve(void 0);
+        }, bodyTimeout);
+        req.on("data", data);
+        req.once("end", end);
+        req.once("error", error);
+        abort.signal.addEventListener("abort", canceled, { once: true });
+        if (abort.signal.aborted) canceled();
+      });
+      if (body === void 0 || abort.signal.aborted) return;
+      const headers = new Headers();
+      for (let i = 0; i < req.rawHeaders.length; i += 2) {
+        const name = req.rawHeaders[i], value = req.rawHeaders[i + 1];
+        if (name !== void 0 && value !== void 0) headers.append(name, value);
+      }
+      const method = req.method ?? "GET";
+      const request = new Request(
+        new URL((req.url ?? "/").replace(/^\/+/, "/"), "http://docker.mock"),
+        {
+          method,
+          headers,
+          signal: abort.signal,
+          ...method !== "GET" && method !== "HEAD" && body.length ? { body: new Uint8Array(body) } : {}
+        }
+      );
+      const response = await runtime.fetch(request);
+      if (abort.signal.aborted) {
+        await response.body?.cancel();
+        return;
+      }
+      const outgoing = Object.fromEntries(response.headers);
+      const cookies = response.headers.getSetCookie();
+      if (cookies.length) outgoing["set-cookie"] = cookies;
+      res.writeHead(response.status, outgoing);
+      if (!response.body) {
+        res.end();
+        return;
+      }
+      res.flushHeaders();
+      const reader = response.body.getReader();
+      const cancel = () => {
+        void reader.cancel().catch(() => {
+        });
+      };
+      abort.signal.addEventListener("abort", cancel, { once: true });
+      try {
+        while (!abort.signal.aborted) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (!res.write(value))
+            await new Promise((resolve) => {
+              const finish = () => {
+                res.off("drain", finish);
+                res.off("close", finish);
+                resolve();
+              };
+              res.once("drain", finish);
+              res.once("close", finish);
+              if (res.destroyed) finish();
+            });
+        }
+        if (!res.destroyed) res.end();
+      } finally {
+        abort.signal.removeEventListener("abort", cancel);
+        reader.releaseLock();
+      }
+    } catch (error) {
+      if (error?.code === "EMULATES_DROP" || abort.signal.aborted || res.headersSent)
+        res.destroy();
+      else reject(500);
+    } finally {
+      res.off("close", onClose);
+    }
+  };
+  const busy = /* @__PURE__ */ new WeakSet();
+  const server = createServer(
+    {
+      maxHeaderSize: 16 * 1024,
+      headersTimeout: 3e4,
+      requestTimeout: 3e4,
+      keepAliveTimeout: 5e3
+    },
+    (req, res) => {
+      if (req.socket.destroyed || busy.has(req.socket)) {
+        req.socket.destroy();
+        return;
+      }
+      busy.add(req.socket);
+      const release = () => {
+        busy.delete(req.socket);
+        res.off("finish", release);
+        res.off("close", release);
+      };
+      res.once("finish", release);
+      res.once("close", release);
+      void handle(req, res);
+    }
+  );
+  if (upgrade)
+    server.on("upgrade", (req, socket, head) => {
+      if (socket.destroyed || busy.has(socket) || !sockets.has(socket)) {
+        socket.destroy();
+        return;
+      }
+      busy.add(socket);
+      void upgrade(req, socket, head);
+    });
+  server.on("connection", (socket) => {
+    if (sockets.size >= maxConnections) {
+      socket.destroy();
+      return;
+    }
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+  });
+  server.once("close", () => runtime.close());
+  const host = options.host ?? "127.0.0.1";
+  await new Promise((resolve, reject) => {
+    const error = (error2) => {
+      server.off("listening", ready);
+      reject(error2);
+    };
+    const ready = () => {
+      server.off("error", error);
+      resolve();
+    };
+    server.once("error", error);
+    server.once("listening", ready);
+    if (path !== void 0) server.listen(path);
+    else server.listen(options.port ?? 0, host);
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address !== null ? address.port : 0;
+  let closing;
+  return {
+    server,
+    host,
+    port,
+    ...path !== void 0 ? { socketPath: path } : {},
+    url: path === void 0 ? `http://${host.includes(":") ? `[${host}]` : host}:${port}` : "http://docker.mock",
+    close: () => closing ??= new Promise((resolve, reject) => {
+      runtime.close();
+      server.close((error) => {
+        if (error && error.code !== "ERR_SERVER_NOT_RUNNING")
+          reject(error);
+        else resolve();
+      });
+      for (const socket of sockets) socket.destroy();
+    })
+  };
+};
+
+// src/server.ts
+var DEFAULT_PORT = 8826;
+var createServer2 = async (options = {}) => {
+  const {
+    port,
+    host,
+    socketPath,
+    maxBodyBytes,
+    bodyTimeoutMs,
+    maxConnections,
+    attachHandshake,
+    attachStreams,
+    ...rest
+  } = options;
+  const attach = createAttachHandshake(attachHandshake, attachStreams);
+  const runtime = createRuntime({ ...rest, onAttach: attach.prepare });
+  try {
+    const listening = await listenDocker(
+      runtime,
+      {
+        ...port !== void 0 ? { port } : {},
+        ...host !== void 0 ? { host } : {},
+        ...socketPath !== void 0 ? { socketPath } : {},
+        ...maxBodyBytes !== void 0 ? { maxBodyBytes } : {},
+        ...bodyTimeoutMs !== void 0 ? { bodyTimeoutMs } : {},
+        ...maxConnections !== void 0 ? { maxConnections } : {}
+      },
+      (req, socket, head) => attach.upgrade(runtime, req, socket, head)
+    );
+    return { ...listening, runtime, attachments: attach.attachments };
+  } catch (error) {
+    runtime.close();
+    throw error;
+  }
+};
+var serveTarget = {
+  name: "docker",
+  defaultPort: DEFAULT_PORT,
+  create: (_values, common) => createRuntime({
+    ...common.adminKey !== void 0 ? { adminKey: common.adminKey } : {},
+    ...common.seed !== void 0 ? { seed: common.seed } : {},
+    ...common.onLog ? { onLog: common.onLog } : {}
+  }),
+  banner: () => ["Docker lifecycle: explicit simulated completion; no image execution or attach"]
+};
+
+export {
+  DEFAULT_PORT,
+  createServer2 as createServer,
+  serveTarget
+};
+//# sourceMappingURL=chunk-ZO7PO2NA.js.map