bayma-repl 0.0.0-stage → 0.12.2

package/dist/bayma.js

@@ -0,0 +1,984 @@
+#!/usr/bin/env node
+
+// packages/cli/src/main.ts
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+// packages/cli/src/docker.ts
+import { existsSync } from "node:fs";
+import {
+  request as httpRequest,
+  STATUS_CODES
+} from "node:http";
+import { buffer } from "node:stream/consumers";
+var API_VERSION = "v1.44";
+var DEFAULT_SOCKET = "/var/run/docker.sock";
+
+class DockerError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "DockerError";
+    this.status = status;
+  }
+}
+function dockerSocket(env) {
+  const host = env.DOCKER_HOST;
+  if (!host)
+    return DEFAULT_SOCKET;
+  if (host.startsWith("unix://"))
+    return host.slice("unix://".length);
+  throw new DockerError(`DOCKER_HOST is ${host}, but bayma reaches Docker only over a Unix socket: set it to unix://PATH, or unset it for ${DEFAULT_SOCKET}`);
+}
+function unreachableReason(socketPath, cause) {
+  switch (cause.code) {
+    case "EACCES":
+    case "EPERM":
+      return `A Docker Engine runs here, but only root and the docker group may use ${socketPath}: add yourself, with sudo usermod -aG docker $USER, and sign in again`;
+    case "ECONNREFUSED":
+      return `Nothing answers on ${socketPath}: start Docker, with sudo systemctl start docker`;
+    case "ENOENT":
+      return existsSync("/etc/debian_version") ? `No Docker Engine runs here (${socketPath} is missing): install one, with sudo apt-get install -y docker.io && sudo usermod -aG docker $USER, and sign in again; or set DOCKER_HOST to unix://PATH of the one you run` : `No Docker Engine runs here (${socketPath} is missing): install one, as https://docs.docker.com/engine/install/ describes; or set DOCKER_HOST to unix://PATH of the one you run`;
+    default:
+      return `Docker could not be reached at ${socketPath}: ${cause.message}`;
+  }
+}
+function describe(call) {
+  return `${call.method} ${call.path}`;
+}
+
+class DockerEngine {
+  socketPath;
+  constructor(socketPath) {
+    this.socketPath = socketPath;
+  }
+  send(call) {
+    const query = new URLSearchParams(call.query);
+    const body = call.body === undefined ? undefined : JSON.stringify(call.body);
+    const request = httpRequest({
+      socketPath: this.socketPath,
+      agent: false,
+      method: call.method,
+      path: `/${API_VERSION}${call.path}${query.size ? `?${query}` : ""}`,
+      headers: body === undefined ? call.headers : {
+        ...call.headers,
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body)
+      }
+    });
+    request.end(body);
+    return request;
+  }
+  unreachable(call, cause) {
+    const errno = cause;
+    return new DockerError(errno.code ? unreachableReason(this.socketPath, errno) : `Docker failed ${describe(call)}: ${errno.message ?? String(cause)}`);
+  }
+  async refusal(call, response) {
+    const status = response.statusCode ?? 0;
+    const text = (await buffer(response)).toString("utf8").trim();
+    let reason = text || STATUS_CODES[status] || "no message";
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed.message === "string")
+        reason = parsed.message;
+    } catch {}
+    return new DockerError(`Docker answered ${status} to ${describe(call)}: ${reason}`, status);
+  }
+  open(call) {
+    return new Promise((resolve, reject) => {
+      const request = this.send(call);
+      request.on("response", (response) => {
+        if ((response.statusCode ?? 0) < 400)
+          resolve(response);
+        else
+          this.refusal(call, response).then(reject, reject);
+      });
+      request.on("error", (cause) => reject(this.unreachable(call, cause)));
+    });
+  }
+  async body(call) {
+    const response = await this.open(call);
+    try {
+      return await buffer(response);
+    } catch (cause) {
+      throw this.unreachable(call, cause);
+    }
+  }
+  async json(call) {
+    return JSON.parse((await this.body(call)).toString("utf8"));
+  }
+  version() {
+    return this.json({ method: "GET", path: "/version" });
+  }
+  async inspectImage(reference) {
+    try {
+      return await this.json({
+        method: "GET",
+        path: `/images/${reference}/json`
+      });
+    } catch (error) {
+      if (error instanceof DockerError && error.status === 404)
+        return null;
+      throw error;
+    }
+  }
+  listImages() {
+    return this.json({ method: "GET", path: "/images/json" });
+  }
+  async pullImage(repository, tag, onEvent) {
+    const call = {
+      method: "POST",
+      path: "/images/create",
+      query: { fromImage: repository, tag }
+    };
+    const response = await this.open(call);
+    let pending = "";
+    let failure;
+    response.setEncoding("utf8");
+    try {
+      for await (const chunk of response) {
+        pending += chunk;
+        const lines = pending.split(`
+`);
+        pending = lines.pop();
+        for (const line of lines) {
+          if (!line.trim())
+            continue;
+          const event = JSON.parse(line);
+          if (event.error)
+            failure = event.error;
+          else
+            onEvent(event);
+        }
+      }
+    } catch (cause) {
+      throw this.unreachable(call, cause);
+    }
+    if (failure !== undefined)
+      throw new DockerError(`Docker could not pull ${repository}: ${failure}`);
+  }
+  async removeImage(reference) {
+    try {
+      await this.body({ method: "DELETE", path: `/images/${reference}` });
+    } catch (error) {
+      if (!(error instanceof DockerError && error.status === 404))
+        throw error;
+    }
+  }
+  listContainers(ancestor) {
+    return this.json({
+      method: "GET",
+      path: "/containers/json",
+      query: { all: "true", filters: JSON.stringify({ ancestor: [ancestor] }) }
+    });
+  }
+  async createContainer(spec) {
+    const { Id } = await this.json({
+      method: "POST",
+      path: "/containers/create",
+      body: spec
+    });
+    return Id;
+  }
+  attachContainer(id, stdin) {
+    const call = {
+      method: "POST",
+      path: `/containers/${id}/attach`,
+      query: {
+        stream: "1",
+        stdin: stdin ? "1" : "0",
+        stdout: "1",
+        stderr: "1"
+      },
+      headers: { Connection: "Upgrade", Upgrade: "tcp" }
+    };
+    return new Promise((resolve, reject) => {
+      const request = this.send(call);
+      request.on("upgrade", (_response, socket, head) => {
+        if (head.length > 0)
+          socket.unshift(head);
+        resolve(socket);
+      });
+      request.on("response", (response) => this.refusal(call, response).then(reject, reject));
+      request.on("error", (cause) => reject(this.unreachable(call, cause)));
+    });
+  }
+  watchExit(id) {
+    const call = {
+      method: "POST",
+      path: `/containers/${id}/wait`,
+      query: { condition: "removed" }
+    };
+    return this.open(call).then((response) => ({
+      status: buffer(response).then((body) => {
+        const { StatusCode, Error: error } = JSON.parse(body.toString("utf8"));
+        if (error?.Message)
+          throw new DockerError(`Docker lost track of the container: ${error.Message}`);
+        return StatusCode;
+      }, (cause) => {
+        throw this.unreachable(call, cause);
+      })
+    }));
+  }
+  async startContainer(id) {
+    await this.body({ method: "POST", path: `/containers/${id}/start` });
+  }
+  async killContainer(id, signal) {
+    try {
+      await this.body({
+        method: "POST",
+        path: `/containers/${id}/kill`,
+        query: { signal }
+      });
+    } catch (error) {
+      if (!(error instanceof DockerError && [404, 409].includes(error.status)))
+        throw error;
+    }
+  }
+  async removeContainer(id) {
+    try {
+      await this.body({
+        method: "DELETE",
+        path: `/containers/${id}`,
+        query: { force: "true" }
+      });
+    } catch (error) {
+      if (!(error instanceof DockerError && error.status === 404))
+        throw error;
+    }
+  }
+}
+function demultiplexer() {
+  let pending = Buffer.alloc(0);
+  return (chunk) => {
+    pending = pending.length > 0 ? Buffer.concat([pending, chunk]) : chunk;
+    const frames = [];
+    let offset = 0;
+    while (offset + 8 <= pending.length) {
+      const size = pending.readUInt32BE(offset + 4);
+      if (offset + 8 + size > pending.length)
+        break;
+      frames.push({
+        stream: pending[offset] === 2 ? "stderr" : "stdout",
+        data: pending.subarray(offset + 8, offset + 8 + size)
+      });
+      offset += 8 + size;
+    }
+    pending = pending.subarray(offset);
+    return frames;
+  };
+}
+
+// packages/cli/src/context.ts
+function connectDocker(context) {
+  return new DockerEngine(dockerSocket(context.env));
+}
+function say(context, text) {
+  context.stdio.stdout.write(`${text}
+`);
+}
+// packages/cli/package.json
+var package_default = {
+  name: "bayma-repl",
+  version: "0.12.2",
+  description: "Set up bayma, a durable engine for REPL sessions, and launch its MCP servers in Docker: npx bayma-repl init",
+  type: "module",
+  license: "MIT",
+  bin: {
+    bayma: "dist/bayma.js"
+  },
+  files: [
+    "dist/bayma.js"
+  ],
+  engines: {
+    node: ">=22"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/eaucoin/bayma.git",
+    directory: "packages/cli"
+  },
+  homepage: "https://github.com/eaucoin/bayma"
+};
+
+// packages/cli/src/release.ts
+var VERSION = package_default.version;
+var IMAGE_REPOSITORY = "ghcr.io/eaucoin/bayma";
+var IMAGE_DIGEST = "sha256:654750dd6a1ddcc36aaf46bf5676c58a3438fab3545da454c05aeb296f42a4e6";
+
+// packages/cli/src/image.ts
+var IMAGE_OVERRIDE = "BAYMA_IMAGE";
+function pinnedImage(digest = IMAGE_DIGEST) {
+  return digest ? `${IMAGE_REPOSITORY}@${digest}` : undefined;
+}
+function baymaImage(env) {
+  const override = env[IMAGE_OVERRIDE];
+  if (override)
+    return { reference: override, pinned: false };
+  const pinned = pinnedImage();
+  if (!pinned)
+    throw new Error(`this bayma ${VERSION} is a development build, with no image pinned: set ${IMAGE_OVERRIDE} to an image such as bayma:${VERSION}, which bun run image builds`);
+  return { reference: pinned, pinned: true };
+}
+function missingImage(image) {
+  return image.pinned ? `bayma's image ${image.reference} is not here: run npx bayma-repl@${VERSION} init` : `${IMAGE_OVERRIDE} names ${image.reference}, which Docker does not have`;
+}
+async function ensureImage(engine, image, report) {
+  if (await engine.inspectImage(image.reference))
+    return "present";
+  if (!image.pinned)
+    throw new Error(missingImage(image));
+  await engine.pullImage(IMAGE_REPOSITORY, IMAGE_DIGEST, report);
+  return "pulled";
+}
+var MB = 1e6;
+function pullReporter(stream) {
+  const layers = new Map;
+  const done = new Set;
+  const line = () => {
+    let current = 0;
+    let total = 0;
+    for (const layer of layers.values()) {
+      current += layer.current;
+      total += layer.total;
+    }
+    return `pulled ${done.size} of ${layers.size} layers, ${Math.round(current / MB)} of ${Math.round(total / MB)} MB downloaded`;
+  };
+  return {
+    event({ id, status, progressDetail }) {
+      if (id === undefined || status === undefined)
+        return;
+      const layer = layers.get(id) ?? { current: 0, total: 0 };
+      layers.set(id, layer);
+      if (status === "Downloading" && progressDetail?.total) {
+        layer.current = progressDetail.current ?? 0;
+        layer.total = progressDetail.total;
+      }
+      if (status === "Download complete")
+        layer.current = layer.total;
+      const finished = (status === "Pull complete" || status === "Already exists") && !done.has(id);
+      if (finished)
+        done.add(id);
+      if (stream.isTTY)
+        stream.write(`\r\x1B[K${line()}`);
+      else if (finished)
+        stream.write(`${line()}
+`);
+    },
+    end() {
+      if (stream.isTTY && layers.size > 0)
+        stream.write(`
+`);
+    }
+  };
+}
+
+// packages/cli/src/launcher.ts
+import { constants } from "node:os";
+
+// packages/cli/src/paths.ts
+import { isAbsolute, join, relative, sep } from "node:path";
+var XDG_DIRECTORIES = [
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "XDG_CACHE_HOME"
+];
+function pathEnvironment(home, env) {
+  const paths = { HOME: home };
+  for (const variable of XDG_DIRECTORIES) {
+    const value = env[variable];
+    if (!value)
+      continue;
+    const within = relative(home, value);
+    if (!isAbsolute(value) || within === ".." || within.startsWith(`..${sep}`) || isAbsolute(within))
+      throw new Error(`${variable} is ${value}, outside HOME (${home}), the one directory bayma's container is given: unset it, or set it to a directory under HOME`);
+    paths[variable] = value;
+  }
+  return paths;
+}
+function xdgRoot(env, variable, fallback) {
+  const configured = env[variable];
+  return configured ? join(configured, "bayma") : join(env.HOME, ...fallback, "bayma");
+}
+function dataRoot(env) {
+  return xdgRoot(env, "XDG_DATA_HOME", [".local", "share"]);
+}
+function stateRoot(env) {
+  return xdgRoot(env, "XDG_STATE_HOME", [".local", "state"]);
+}
+function cacheRoot(env) {
+  return xdgRoot(env, "XDG_CACHE_HOME", [".cache"]);
+}
+function toolbeltDir(env) {
+  return join(dataRoot(env), "toolbelt");
+}
+var TOOLBELT_VERSION_FILE = ".bayma-toolbelt-version";
+function cliRoot(env) {
+  return join(dataRoot(env), "cli");
+}
+function installedCli(env, version) {
+  return join(cliRoot(env), version, "bayma.js");
+}
+
+// packages/cli/src/launcher.ts
+var SNAPSHOT_CAPABILITIES = ["CHECKPOINT_RESTORE", "SYS_PTRACE"];
+var SNAPSHOT_SECURITY = ["seccomp=unconfined"];
+function telemetryEnvironment(env) {
+  return Object.entries(env).filter(([name, value]) => name.startsWith("OTEL_") && value).map(([name, value]) => `${name}=${value}`).sort();
+}
+function containerSpec(image, command, args, invocation) {
+  const stdin = command === "mcp-stdio";
+  return {
+    Image: image,
+    Cmd: [command, ...args],
+    User: `${invocation.uid}:${invocation.gid}`,
+    Env: [
+      ...Object.entries(pathEnvironment(invocation.home, invocation.env)).map(([name, value]) => `${name}=${value}`),
+      ...telemetryEnvironment(invocation.env)
+    ],
+    WorkingDir: invocation.cwd,
+    AttachStdin: stdin,
+    AttachStdout: true,
+    AttachStderr: true,
+    OpenStdin: stdin,
+    StdinOnce: stdin,
+    Tty: false,
+    HostConfig: {
+      AutoRemove: true,
+      Binds: [`${invocation.home}:${invocation.home}`],
+      CapAdd: SNAPSHOT_CAPABILITIES,
+      SecurityOpt: SNAPSHOT_SECURITY,
+      NetworkMode: "host"
+    }
+  };
+}
+var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+async function runContainer(engine, image, spec, stdio) {
+  let running;
+  let cancelled;
+  const onSignal = (signal) => {
+    if (running === undefined) {
+      cancelled ??= signal;
+      return;
+    }
+    engine.killContainer(running, signal).catch((error) => stdio.stderr.write(`bayma: could not forward ${signal}: ${error instanceof Error ? error.message : String(error)}
+`));
+  };
+  for (const signal of FORWARDED_SIGNALS)
+    process.on(signal, onSignal);
+  try {
+    let id;
+    try {
+      id = await engine.createContainer(spec);
+    } catch (error) {
+      if (error instanceof DockerError && error.status === 404)
+        throw new Error(missingImage(image));
+      throw error;
+    }
+    let socket;
+    let exit;
+    let started = false;
+    try {
+      socket = await engine.attachContainer(id, spec.OpenStdin);
+      exit = await engine.watchExit(id);
+      if (cancelled === undefined) {
+        await engine.startContainer(id);
+        started = true;
+      }
+    } catch (error) {
+      await discard(engine, id, socket, exit);
+      throw error;
+    }
+    if (!started) {
+      await discard(engine, id, socket, exit);
+      return 128 + constants.signals[cancelled];
+    }
+    running = id;
+    if (cancelled !== undefined)
+      onSignal(cancelled);
+    return await forwardUntilExit(socket, exit, spec.OpenStdin, stdio);
+  } finally {
+    for (const signal of FORWARDED_SIGNALS)
+      process.off(signal, onSignal);
+  }
+}
+async function discard(engine, id, socket, exit) {
+  socket?.destroy();
+  exit?.status.catch(() => {
+    return;
+  });
+  await engine.removeContainer(id).catch(() => {
+    return;
+  });
+}
+async function forwardUntilExit(socket, exit, stdin, stdio) {
+  const frames = demultiplexer();
+  const output = new Promise((resolve) => {
+    socket.on("data", (chunk) => {
+      for (const { stream, data } of frames(chunk)) {
+        const target = stdio[stream];
+        if (!target.write(data)) {
+          socket.pause();
+          target.once("drain", () => socket.resume());
+        }
+      }
+    });
+    socket.on("error", () => {
+      return;
+    });
+    socket.on("close", () => resolve());
+  });
+  if (stdin)
+    stdio.stdin.pipe(socket);
+  try {
+    const [status] = await Promise.all([exit.status, output]);
+    return status;
+  } finally {
+    if (stdin)
+      stdio.stdin.unpipe(socket);
+    socket.destroy();
+  }
+}
+
+// packages/cli/src/setup.ts
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync as existsSync3,
+  mkdirSync,
+  readdirSync,
+  renameSync
+} from "node:fs";
+import { dirname } from "node:path";
+
+// packages/cli/src/clients.ts
+import { spawn } from "node:child_process";
+import { accessSync, constants as constants2, existsSync as existsSync2, readFileSync } from "node:fs";
+import { delimiter, isAbsolute as isAbsolute2, join as join2 } from "node:path";
+var SERVER_NAME = "bayma";
+function claudeRegistration(home, env) {
+  const path = join2(env.CLAUDE_CONFIG_DIR || home, ".claude.json");
+  if (!existsSync2(path))
+    return;
+  const config = JSON.parse(readFileSync(path, "utf8"));
+  const server = config.mcpServers?.[SERVER_NAME];
+  if (server?.command === undefined)
+    return;
+  return { command: server.command, args: server.args ?? [] };
+}
+function tomlStrings(text) {
+  return [...text.matchAll(/"(?:[^"\\]|\\.)*"|'[^']*'/g)].map(([value]) => value.startsWith("'") ? value.slice(1, -1) : JSON.parse(value));
+}
+function codexRegistration(home, env) {
+  const path = join2(env.CODEX_HOME || join2(home, ".codex"), "config.toml");
+  if (!existsSync2(path))
+    return;
+  const lines = readFileSync(path, "utf8").split(`
+`);
+  const header = lines.findIndex((line) => /^\s*\[\s*mcp_servers\s*\.\s*(bayma|"bayma")\s*\]\s*$/.test(line));
+  if (header === -1)
+    return;
+  const end = lines.findIndex((line, index) => index > header && /^\s*\[/.test(line));
+  const table = lines.slice(header + 1, end === -1 ? undefined : end).join(`
+`);
+  const command = /^\s*command\s*=\s*(.*)$/m.exec(table)?.[1];
+  const args = /^\s*args\s*=\s*\[([^\]]*)\]/m.exec(table)?.[1];
+  if (command === undefined)
+    return;
+  const [executable] = tomlStrings(command);
+  if (executable === undefined)
+    return;
+  return {
+    command: executable,
+    args: args === undefined ? [] : tomlStrings(args)
+  };
+}
+var MCP_CLIENTS = [
+  {
+    name: "Claude Code",
+    executable: "claude",
+    add: ({ command, args }) => [
+      "mcp",
+      "add",
+      "--scope",
+      "user",
+      SERVER_NAME,
+      "--",
+      command,
+      ...args
+    ],
+    remove: ["mcp", "remove", "--scope", "user", SERVER_NAME],
+    registered: claudeRegistration
+  },
+  {
+    name: "Codex",
+    executable: "codex",
+    add: ({ command, args }) => [
+      "mcp",
+      "add",
+      SERVER_NAME,
+      "--",
+      command,
+      ...args
+    ],
+    remove: ["mcp", "remove", SERVER_NAME],
+    registered: codexRegistration
+  }
+];
+function isExecutable(path) {
+  try {
+    accessSync(path, constants2.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findExecutable(name, env) {
+  if (name.includes("/"))
+    return isExecutable(name) ? name : undefined;
+  for (const directory of (env.PATH ?? "").split(delimiter)) {
+    if (!directory)
+      continue;
+    const candidate = join2(directory, name);
+    if (isExecutable(candidate))
+      return candidate;
+  }
+  return;
+}
+function runCommand(file, args, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, args, {
+      env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    child.stdout.setEncoding("utf8").on("data", (chunk) => output += chunk);
+    child.stderr.setEncoding("utf8").on("data", (chunk) => output += chunk);
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ status: code ?? 1, output }));
+  });
+}
+async function register(client, executable, launch, env) {
+  await runCommand(executable, client.remove, env);
+  return runCommand(executable, client.add(launch), env);
+}
+function registrationProblem(launch, env) {
+  const [cli, command] = launch.args;
+  if (!findExecutable(launch.command, env))
+    return isAbsolute2(launch.command) ? `${launch.command} is not there to run` : `${launch.command} is not on PATH`;
+  if (cli === undefined || !existsSync2(cli))
+    return `${cli ?? "no command"} is not there`;
+  if (command !== "mcp-stdio")
+    return `it does not run mcp-stdio`;
+  return;
+}
+
+// packages/cli/src/setup.ts
+function installCli(paths, bundle) {
+  const target = installedCli(paths, VERSION);
+  mkdirSync(dirname(target), { recursive: true });
+  const staging = `${target}.${process.pid}`;
+  copyFileSync(bundle, staging);
+  chmodSync(staging, 493);
+  renameSync(staging, target);
+  return target;
+}
+function launchCommand(node, cli) {
+  return { command: node, args: [cli, "mcp-stdio"] };
+}
+function mcpServersJson(launch) {
+  return JSON.stringify({ mcpServers: { [SERVER_NAME]: launch } }, null, 2);
+}
+function otherVersions(paths) {
+  const root = cliRoot(paths);
+  if (!existsSync3(root))
+    return [];
+  return readdirSync(root).filter((version) => version !== VERSION);
+}
+function runInImage(context, engine, image, command, output) {
+  return runContainer(engine, image, containerSpec(image.reference, command, [], context), { ...context.stdio, stdout: output });
+}
+async function setUp(context, upgrade) {
+  const paths = pathEnvironment(context.home, context.env);
+  if (upgrade) {
+    const others = otherVersions(paths);
+    say(context, `Upgrading to bayma ${VERSION}${others.length > 0 ? ` from ${others.join(", ")}` : ""}. MCP clients running now keep their bayma until they restart; once they do, a REPL session another version snapshotted is restored from its checkpoints rather than resumed live, since a process snapshot is restored only by the version that took it.`);
+  }
+  const image = baymaImage(context.env);
+  const engine = connectDocker(context);
+  const docker = await engine.version();
+  say(context, `Docker ${docker.Version} answers at ${engine.socketPath}`);
+  const progress = pullReporter(context.stdio.stderr);
+  if (image.pinned)
+    say(context, `pulling bayma ${VERSION}'s image, ${image.reference}`);
+  const pulled = await ensureImage(engine, image, (event) => progress.event(event));
+  progress.end();
+  say(context, `image ${image.reference}: ${pulled}`);
+  say(context, "installing the toolbelt bundled with bayma");
+  const installed = await runInImage(context, engine, image, "install-toolbelt", context.stdio.stderr);
+  if (installed !== 0)
+    throw new Error(`bayma install-toolbelt failed with status ${installed}, as it says above; bayma is not registered`);
+  say(context, "checking each runtime with bayma doctor");
+  const doctor = await runInImage(context, engine, image, "doctor", context.stdio.stdout);
+  const cli = installCli(paths, context.bundle);
+  say(context, `installed bayma ${VERSION} at ${cli}`);
+  const launch = launchCommand(context.node, cli);
+  let failed = false;
+  for (const client of MCP_CLIENTS) {
+    const executable = findExecutable(client.executable, context.env);
+    if (!executable) {
+      say(context, `${client.name}: no ${client.executable} on PATH, so not registered`);
+      continue;
+    }
+    const result = await register(client, executable, launch, context.env);
+    const ran = [client.executable, ...client.add(launch)].join(" ");
+    if (result.status === 0)
+      say(context, `${client.name}: registered bayma, with ${ran}`);
+    else {
+      failed = true;
+      say(context, `${client.name}: ${ran} failed with status ${result.status}: ${result.output.trim()}`);
+    }
+  }
+  say(context, `For any other MCP client:
+${mcpServersJson(launch)}`);
+  if (doctor !== 0)
+    say(context, `warning: bayma doctor failed with status ${doctor}, so a runtime its report above names as failing does not work here; bayma is registered all the same, for the runtimes that do. npx bayma-repl doctor checks them again.`);
+  return failed ? 1 : 0;
+}
+
+// packages/cli/src/status.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function readStatus(context) {
+  const paths = pathEnvironment(context.home, context.env);
+  const status = {
+    version: VERSION,
+    docker: {},
+    image: {},
+    toolbelt: { path: toolbeltDir(paths) },
+    installed: existsSync4(cliRoot(paths)) ? readdirSync2(cliRoot(paths)).sort() : [],
+    registrations: MCP_CLIENTS.map((client) => {
+      const launch = client.registered(context.home, context.env);
+      return {
+        client: client.name,
+        launch,
+        problem: launch && registrationProblem(launch, context.env)
+      };
+    })
+  };
+  const versionFile = join3(status.toolbelt.path, TOOLBELT_VERSION_FILE);
+  if (existsSync4(versionFile))
+    status.toolbelt.version = readFileSync2(versionFile, "utf8").trim();
+  try {
+    status.image.image = baymaImage(context.env);
+  } catch (error) {
+    status.image.problem = message(error);
+  }
+  try {
+    const engine = connectDocker(context);
+    status.docker.socket = engine.socketPath;
+    status.docker.version = (await engine.version()).Version;
+    if (status.image.image !== undefined)
+      status.image.present = await engine.inspectImage(status.image.image.reference) !== null;
+  } catch (error) {
+    status.docker.problem = message(error);
+  }
+  return status;
+}
+function renderStatus(status) {
+  const lines = [`bayma ${status.version}`];
+  lines.push(status.docker.problem === undefined ? `Docker: ${status.docker.version} at ${status.docker.socket}` : `Docker: ${status.docker.problem}`);
+  const { image, present, problem } = status.image;
+  lines.push(image === undefined ? `image: ${problem}` : present === undefined ? `image: ${image.reference}, not known to be here without Docker` : present ? `image: ${image.reference}` : `image: ${missingImage(image)}`);
+  lines.push(status.toolbelt.version === undefined ? `toolbelt: not installed at ${status.toolbelt.path}` : `toolbelt: ${status.toolbelt.version} at ${status.toolbelt.path}`);
+  lines.push(`installed for MCP clients: ${status.installed.length > 0 ? status.installed.join(", ") : "none"}`);
+  for (const { client, launch, problem } of status.registrations) {
+    if (launch === undefined) {
+      lines.push(`${client}: bayma is not registered`);
+      continue;
+    }
+    const command = [launch.command, ...launch.args].join(" ");
+    lines.push(problem === undefined ? `${client}: ${command}` : `${client}: ${command}, which is broken: ${problem}; npx bayma-repl init registers bayma again`);
+  }
+  return lines.join(`
+`);
+}
+async function showStatus(context) {
+  say(context, renderStatus(await readStatus(context)));
+  return 0;
+}
+
+// packages/cli/src/uninstall.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, rmSync } from "node:fs";
+async function pulledImages(engine) {
+  return (await engine.listImages()).flatMap(({ RepoDigests }) => (RepoDigests ?? []).filter((reference) => reference.startsWith(`${IMAGE_REPOSITORY}@`)));
+}
+async function running(engine, references) {
+  let count = 0;
+  for (const reference of references)
+    count += (await engine.listContainers(reference)).filter(({ State }) => State === "running").length;
+  return count;
+}
+function remove(context, path, what) {
+  if (!existsSync5(path))
+    return;
+  rmSync(path, { recursive: true, force: true });
+  say(context, `removed ${what}, ${path}`);
+}
+async function uninstall(context, purge) {
+  const paths = pathEnvironment(context.home, context.env);
+  let docker;
+  try {
+    const engine = connectDocker(context);
+    docker = { engine, images: await pulledImages(engine) };
+  } catch (error) {
+    say(context, `${error instanceof Error ? error.message : String(error)}; bayma's images are left as they are`);
+  }
+  if (docker !== undefined) {
+    const override = context.env[IMAGE_OVERRIDE];
+    const servers = await running(docker.engine, override ? [...docker.images, override] : docker.images);
+    if (servers > 0)
+      throw new Error(`bayma runs in ${servers} container${servers === 1 ? "" : "s"} now, serving MCP clients: close them, then uninstall`);
+  }
+  for (const client of MCP_CLIENTS) {
+    const executable = findExecutable(client.executable, context.env);
+    if (!executable)
+      continue;
+    const result = await runCommand(executable, client.remove, context.env);
+    say(context, result.status === 0 ? `${client.name}: removed bayma` : `${client.name}: removed nothing: ${result.output.trim()}`);
+  }
+  if (docker !== undefined)
+    for (const reference of docker.images) {
+      await docker.engine.removeImage(reference);
+      say(context, `removed the image ${reference}`);
+    }
+  remove(context, dataRoot(paths), "the toolbelt bundled with bayma and bayma's commands for MCP clients");
+  remove(context, cacheRoot(paths), "bayma's cache");
+  const state = stateRoot(paths);
+  if (!existsSync5(state))
+    return 0;
+  if (!purge) {
+    say(context, `kept REPL sessions' state, in ${state}; uninstall --purge removes it`);
+    return 0;
+  }
+  const directories = readdirSync3(state).length;
+  say(context, `removing REPL sessions' state, of the ${directories} director${directories === 1 ? "y" : "ies"} MCP clients launched bayma from: every REPL session's catalog entry, execution history, checkpoints, and process snapshots`);
+  remove(context, state, "REPL sessions' state");
+  return 0;
+}
+
+// packages/cli/src/main.ts
+function usage() {
+  return `Usage: npx bayma-repl <command>
+
+bayma is a durable engine for REPL sessions, served to agents by its MCP
+servers. This command sets it up on Linux (x64) with Docker, and runs it in
+bayma's image of its own version.
+
+Commands:
+  init
+      pull bayma's image, install the toolbelt bundled with bayma, check
+      each runtime with bayma's doctor, and register bayma with Claude Code
+      and Codex, as an MCP server they launch over stdio
+  upgrade
+      set up this version of bayma in place of the one set up now; run it
+      as npx bayma-repl@latest upgrade
+  status
+      show what is set up of bayma here, and what of it would not work
+  mcp-stdio [OPTIONS]
+      serve MCP over stdio, as MCP clients launch bayma
+  mcp-http [OPTIONS]
+      serve MCP over Streamable HTTP; its default host, 127.0.0.1, is this
+      machine's loopback
+  doctor [OPTIONS]
+      check that each runtime works here
+  uninstall [--purge]
+      remove bayma's registrations, its commands for MCP clients, its
+      images, its toolbelt, and its cache; with --purge, REPL sessions'
+      state too
+  version
+      print the version
+  help
+      show this help
+
+OPTIONS are those of the same command in bayma's image, passed to it as
+given. bayma's servers export OpenTelemetry traces, metrics, and logs where
+the OTEL_* variables set here say.`;
+}
+var LAUNCHED = [
+  "mcp-stdio",
+  "mcp-http",
+  "doctor"
+];
+async function launch(context, command, args) {
+  const image = baymaImage(context.env);
+  return runContainer(connectDocker(context), image, containerSpec(image.reference, command, args, context), context.stdio);
+}
+function expectArgs(command, args, allowed) {
+  const unknown = args.find((arg) => !allowed.includes(arg));
+  if (unknown !== undefined)
+    throw new Error(`${command} takes no ${unknown}; see npx bayma-repl help`);
+}
+function processContext() {
+  return {
+    uid: process.getuid(),
+    gid: process.getgid(),
+    home: process.env.HOME || homedir(),
+    cwd: process.cwd(),
+    env: process.env,
+    node: process.execPath,
+    bundle: fileURLToPath(import.meta.url),
+    stdio: {
+      stdin: process.stdin,
+      stdout: process.stdout,
+      stderr: process.stderr
+    }
+  };
+}
+async function run(argv) {
+  const [command = "help", ...args] = argv;
+  if (command === "help" || command === "--help" || command === "-h") {
+    process.stdout.write(`${usage()}
+`);
+    return 0;
+  }
+  if (command === "version" || command === "--version" || command === "-V") {
+    process.stdout.write(`${VERSION}
+`);
+    return 0;
+  }
+  const platform = `${process.platform}-${process.arch}`;
+  if (platform !== "linux-x64")
+    throw new Error(`bayma runs on Linux (x64) with Docker, and this is ${platform}`);
+  const context = processContext();
+  if (LAUNCHED.includes(command))
+    return launch(context, command, args);
+  switch (command) {
+    case "init":
+    case "upgrade":
+      expectArgs(command, args, []);
+      return setUp(context, command === "upgrade");
+    case "status":
+      expectArgs(command, args, []);
+      return showStatus(context);
+    case "uninstall":
+      expectArgs(command, args, ["--purge"]);
+      return uninstall(context, args.includes("--purge"));
+    default:
+      process.stderr.write(`${usage()}
+`);
+      return 2;
+  }
+}
+var status;
+try {
+  status = await run(process.argv.slice(2));
+} catch (error) {
+  process.stderr.write(`bayma: ${error instanceof Error ? error.message : String(error)}
+`);
+  status = 1;
+}
+process.exit(status);

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "bayma-repl",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.12.2",
+  "description": "Set up bayma, a durable engine for REPL sessions, and launch its MCP servers in Docker: npx bayma-repl init",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "bayma": "dist/bayma.js"
+  },
+  "files": [
+    "dist/bayma.js"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eaucoin/bayma.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/eaucoin/bayma"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.