cortad 0.3.9 → 0.3.11

package/lib/mongo.mjs

@@ -1,11 +1,14 @@
 // A MongoDB database copied for a session on the server it lives on, with MongoDB's own tools: a
-// dump of it restored under a name of ours, and dropped after. The address carries the password, so
-// it reaches mongodump and mongorestore through a config file only this user can read, and mongosh
-// through its environment: never a command line another process on this machine can read.
+// dump of it restored under a name of ours, and dropped after. Or, for an app that names its
+// databases in its code, the whole server copied into a container of ours (serveMongo). The address
+// carries the password, so it reaches mongodump and mongorestore through a config file only its user
+// can read, and mongosh through its environment: never a command line another process can read.
 import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { docker, dockerUp, freePort, runCopy, servedBy, until } from "./container.mjs";
 
 // A database bigger than this is not copied: said instead, so the person decides.
 export const MONGO_CAP = 1024 ** 3;
@@ -72,3 +75,61 @@ export async function cloneMongo(conn, source, clone) {
 export async function dropMongo(conn, clone, source) {
   return (await shell(withDb(conn.uri, clone, source), `c.getDB(${JSON.stringify(clone)}).dropDatabase()`)).code === 0;
 }
+
+// The address with only this host in it, for a reader that talks to the one server it names: a
+// replica set's member list holds names only its own network resolves.
+function directTo(uri, hostPort) {
+  const [, head, hosts, rest = "", query = "", tail = ""] = /^([^:]+:\/\/)([^/?#]*)(\/[^?#]*)?(\?[^#]*)?(#.*)?$/.exec(uri);
+  const cut = hosts.lastIndexOf("@");
+  const params = new URLSearchParams(query.slice(1));
+  params.delete("replicaSet");
+  params.set("directConnection", "true");
+  return `${head}${cut >= 0 ? hosts.slice(0, cut + 1) : ""}${hostPort}${rest || "/"}?${params}${tail}`;
+}
+
+// A replica set that asks for a password needs a key its members share, one member or not: made in
+// the container before mongod starts, readable by mongod alone.
+const KEYED = 'umask 077; head -c 756 /dev/urandom | base64 > /tmp/cortad.key; chown mongodb /tmp/cortad.key; exec docker-entrypoint.sh mongod "$@"';
+
+// The whole server copied into a container of ours (lib/container.mjs) with MongoDB's own tools,
+// which the container has whatever this machine lacks: every database, its indexes, and its users
+// and roles, so the app signs in there as it does on the original. A server the app signs in to is
+// copied into one that asks for a password too: the dump is restored by a user of ours, made through
+// MongoDB's localhost exception and dropped after. Answers { port } or { why }.
+export async function serveMongo(conn, name) {
+  if (!(await dockerUp())) return { why: "docker" };
+  const from = await servedBy(conn.port);
+  let image = from?.image;
+  if (!image) {
+    const v = await shell(conn.uri, "print(c.getDB('admin').version())");
+    if (v.code !== 0) return { why: refusal(v) };
+    image = `mongo:${v.out.trim()}`;
+  }
+  const port = await freePort();
+  const replSet = new URLSearchParams(/\?([^#]*)/.exec(conn.uri)?.[1] ?? "").get("replicaSet");
+  const restorer = conn.user ? { user: `cortad_${randomBytes(4).toString("hex")}`, pwd: randomBytes(24).toString("hex") } : null;
+  const mongod = ["--port", String(port), "--bind_ip_all", ...(replSet ? ["--replSet", replSet] : []), ...(restorer ? ["--auth"] : [])];
+  const started = restorer && replSet
+    ? { entrypoint: "bash", args: ["-c", KEYED, "bash", ...mongod, "--keyFile", "/tmp/cortad.key"] }
+    : { args: mongod };
+  if (!(await runCopy({ name, image, port, network: from?.net, ...started }))) return { why: "container" };
+  const inside = (script, env = {}) => docker(["exec", ...Object.keys(env).flatMap((k) => ["-e", k]), name, "mongosh", "--quiet", "--port", String(port), "--eval", script], { env });
+  if (!(await until(async () => (await inside("db.runCommand({ ping: 1 }).ok")).out.trim() === "1", 90_000))) return { why: "other" };
+  if (replSet) {
+    await inside(`rs.initiate({ _id: ${JSON.stringify(replSet)}, members: [{ _id: 0, host: "127.0.0.1:${port}" }] })`);
+    if (!(await until(async () => (await inside("db.hello().isWritablePrimary")).out.trim() === "true", 60_000))) return { why: "other" };
+  }
+  if (restorer && (await inside(`print(db.getSiblingDB("admin").createUser({ user: ${JSON.stringify(restorer.user)}, pwd: process.env.CORTAD_PWD, roles: ["root"] }).ok)`, { CORTAD_PWD: restorer.pwd })).out.trim() !== "1") return { why: "other" };
+  const source = directTo(conn.uri, from?.ip ? `${from.ip}:${from.inner}` : `host.docker.internal:${conn.port}`);
+  const target = `mongodb://${restorer ? `${restorer.user}:${restorer.pwd}@` : ""}127.0.0.1:${port}/?directConnection=true${restorer ? "&authSource=admin" : ""}`;
+  const size = await docker(["exec", "-e", "CORTAD_SOURCE", name, "mongosh", "--nodb", "--quiet", "--eval", "print(new Mongo(process.env.CORTAD_SOURCE).getDB('admin').adminCommand({ listDatabases: 1 }).totalSize)"], { env: { CORTAD_SOURCE: source } });
+  if (!size.ok) return { why: refusal({ code: 1, err: size.err + size.out }) };
+  if (Number(size.out.trim()) > MONGO_CAP) return { why: "big" };
+  // Each address goes into a file only the container's own user reads, never onto a command line.
+  const copy = await docker(["exec", "-e", "CORTAD_FROM", "-e", "CORTAD_TO", name, "bash", "-c",
+    "set -o pipefail; umask 077; printf '%s\\n' \"$CORTAD_FROM\" > /tmp/from.yaml && printf '%s\\n' \"$CORTAD_TO\" > /tmp/to.yaml && mongodump --config=/tmp/from.yaml --archive --quiet | mongorestore --config=/tmp/to.yaml --archive --quiet --nsExclude='config.*'; s=$?; rm -f /tmp/from.yaml /tmp/to.yaml; exit $s"],
+  { env: { CORTAD_FROM: `uri: ${JSON.stringify(source)}`, CORTAD_TO: `uri: ${JSON.stringify(target)}` }, timeout: 900_000 });
+  if (!copy.ok) return { why: refusal({ code: 1, err: copy.err }) };
+  if (restorer) await docker(["exec", "-e", "CORTAD_TARGET", name, "mongosh", "--nodb", "--quiet", "--eval", `new Mongo(process.env.CORTAD_TARGET).getDB("admin").dropUser(${JSON.stringify(restorer.user)})`], { env: { CORTAD_TARGET: target } });
+  return { port };
+}

package/lib/proof.mjs

@@ -991,7 +991,14 @@ export function canaryOf(exchanges, proof, found = null, own = []) {
   if (carried(b1)) add("shared-history", "theirs", "A new conversation carried an earlier one's words: every conversation on this endpoint shares what your app keeps, so test conversations would read each other's.");
   const met = metIn(a1, own);
   if (met) add("unreadable", "theirs", met);
-  else if (!ok(a1.status) || !replyOf(a1).text.trim()) add("unreadable", ok(a1.status) ? "ours" : "theirs", ok(a1.status) ? "The reply to the first message could not be read as words." : `Your app answered ${a1.status} to the first message.`);
+  else if (!ok(a1.status)) add("unreadable", "theirs", `Your app answered ${a1.status} to the first message.`);
+  else if (!replyOf(a1).text.trim()) {
+    // No words because the app's own model refused it is the app's key, card or model, never our
+    // reading: a wrong key in the twin's env file held Run as "could not be read as words", ours.
+    const calls = generation(a1);
+    const refused = calls.length && calls.every((c) => REFUSED.has(Number(c.status))) ? calls.at(-1) : null;
+    add("unreadable", refused ? "theirs" : "ours", refused ? `The first message reached your app's model, and the ${modelCall(refused)}, so no words came back.` : "The reply to the first message could not be read as words.");
+  }
   const instructions = str(generation(a1).find((c) => typeof c.instructions === "string")?.instructions).trim();
   const pieces = piecesOf(instructions);
   const request = norm(a1.body);

package/lib/read-text.mjs

@@ -87,30 +87,30 @@ const listed = (names) => (names.length > 1 ? `${names.slice(0, -1).join(", ")}
 
 // What the connect command does on this machine, from the facts it keeps in the runner's record:
 // what it started and stops, the database copies, the settings its app runs with, what it loads,
-// what a run holds and puts back, and what it keeps and writes outside this repository. At most
-// eight lines, the two for the person first.
+// what a run holds and puts back, and what it keeps outside this repository. The first line is the
+// one the terminal says at connect (connectedText); the rest is read when someone asks.
 export function machineText(f) {
   if (!f) return ["No connect command is running for this repository now, so nothing Cortad started is running here."];
   const lines = [
     f.started
-      ? `For the person: Cortad started your app in ${f.dir === "." ? "this folder" : f.dir} and stops it, with everything it started for it, when you press Ctrl-C in its terminal; your code and settings files are never edited.`
-      : `For the person: Cortad uses your app already running on port ${f.port} and leaves it running when you press Ctrl-C in its terminal; your code and settings files are never edited.`,
-    f.copies === "made"
-      ? "For the person: Where Cortad could copy a database, your app runs on the copy, made from your own at every connect and deleted when this command ends, so records created in a copy are gone at the next connect; keep records every run needs in your own database. Each Data line in status says what happens to one store."
-      : "For the person: No copy of a database was made for this session, so what test conversations create stays where your app keeps its data; each Data line in status names one store.",
+      ? `Cortad started your app in ${f.dir === "." ? "this folder" : f.dir} and stops it when this command stops. Your code and settings files are never edited.`
+      : `Cortad uses your app already running on port ${f.port} and leaves it running. Your code and settings files are never edited.`,
   ];
+  if (f.copies === "made") lines.push("Test conversations save into a copy of your database, made fresh at each connect and deleted when this command stops. Your own data is not changed.");
   // Env values reach only a process the command started itself.
-  if (f.started) lines.push(f.changed?.length ? `Your env file values go into your app's process alone, with ${listed(f.changed)} set for this session only; no value is sent to Cortad.` : "Your env file values go into your app's process alone, unchanged; no value is sent to Cortad.");
-  lines.push(f.hooked ? "A hook loaded into your app records each request that reaches a model and the model calls it makes; request headers stay on this machine and are deleted when the command stops."
-    : f.proxy ? `A local proxy on port ${f.proxy} sees each request sent to it and the model calls your app makes through it; request headers stay on this machine and are deleted when the command stops.`
-      : "Nothing is loaded into your app, since Cortad did not start it, so its model calls are not seen.");
+  if (f.started) lines.push(`Your env values stay on this machine${f.changed?.length ? `, with ${listed(f.changed)} set for this session only` : ""}. None is sent to Cortad.`);
+  lines.push(f.hooked ? "Cortad sees each request that reaches your model and the model calls it makes. Request headers stay on this machine and are deleted when the command stops."
+    : f.proxy ? `A local proxy on port ${f.proxy} sees each request sent to it and the model calls your app makes through it. Request headers stay on this machine and are deleted when the command stops.`
+      : "Cortad did not start your app, so it does not see the calls your app makes to its model.");
   // Only the hook holds a write or records a file: through the proxy, or with nothing loaded, both go as the app does them.
-  lines.push(f.hooked ? "During a run, a write your app sends to a service off this machine, such as a payment or an email, is answered inside your app and never sent, unless it carries a test key, goes to a provider's sandbox, or goes to a host you said yes to on the card; a call named as a read where every call is a POST, such as customers.get, goes out."
-    : "During a run, a write your app sends to a service off this machine, such as a payment or an email, is sent for real.");
-  lines.push(f.hooked ? "Files your app writes in its own folder during a run are put back when run_status reads the run's end; its log files are left as they are." : "Files your app writes in its own folder stay as it writes them.");
-  lines.push("Kept between connects in ~/.cortad on this machine: this repository's key for later runs, the key the test accounts' passwords are made from, the files to put back, a list of what to undo, and your app's output from the last session with the values from your env files masked, which the next connect starts over.");
+  lines.push(f.hooked ? "During a run, anything your app would send to an outside service, such as a payment or an email, is answered inside your app and never sent, unless it carries a test key, goes to a provider's sandbox, or goes to a host you allowed on the card. A call that only reads goes out."
+    : "During a run, what your app sends to an outside service, such as a payment or an email, is sent for real.");
+  lines.push(f.hooked ? "Files your app writes in its own folder during a run are put back when the run ends. Its log files are left as they are." : "Files your app writes in its own folder stay as it writes them.");
+  lines.push("Kept in ~/.cortad on this machine between connects: this repository's key, the key the test accounts' passwords are made from, what to put back after a run, and your app's output from the last session with your env values masked.");
   return lines;
 }
+// What the terminal says once the app answers: the one line the person needs.
+export const connectedText = (f) => machineText(f).slice(0, 1);
 
 export function showText(d, show, page = 1) {
   if (!d.read || (d.read.complete === false && show !== "reviews")) return "Cortad is still reading this repository.";

package/lib/stores.mjs

@@ -1,14 +1,17 @@
 // Your app's database servers, kept out of the run's way. A run creates people, conversations and
-// records by the hundred; an app pointed at Postgres, Redis, MongoDB or a Qdrant collection kept
-// every one of them. So each store the app's settings name on this machine is copied on its own
-// server, under a name of ours, the app is started pointed at the copy through the same settings,
-// and the copy is deleted when this command ends. The original is only ever read. What is not
-// copied is said before a run: which store, and that what test conversations create stays in it. A store off
-// this machine is copied where it can be (lib/hosted.mjs) and otherwise holds Run.
+// records by the hundred; an app pointed at Postgres, Redis, MongoDB, Elasticsearch or a Qdrant
+// collection kept every one of them. So each store the app's settings name on this machine is copied
+// on its own server under a name of ours, or, where the app names its databases in its code, as a
+// whole server in a container of ours (lib/container.mjs); the app is started pointed at the copy
+// through the same settings, and the copy is deleted when this command ends. The original is only
+// ever read. A store no copy is made of holds Run until the person says yes to writing into it. A
+// store off this machine is copied where it can be (lib/hosted.mjs) and otherwise holds Run.
 import { createHash } from "node:crypto";
+import { copyName, removeCopy } from "./container.mjs";
+import { serveElastic } from "./elastic.mjs";
 import { hostedKeeper } from "./hosted.mjs";
 import { ledger } from "./ledger.mjs";
-import { cloneMongo, dropMongo, withDb } from "./mongo.mjs";
+import { cloneMongo, dropMongo, serveMongo, withDb } from "./mongo.mjs";
 import { clonePg, dropPg } from "./pg.mjs";
 import { cloneQdrant, dropQdrant } from "./qdrant.mjs";
 import { cloneRedis, dropRedis } from "./redis.mjs";
@@ -29,12 +32,14 @@ const COPY = {
   mongo: { copy: (s, clone) => cloneMongo(s.conn, s.db, clone), drop: (s, clone) => dropMongo(s.conn, clone, s.db) },
   qdrant: { copy: (s, clone) => cloneQdrant(s.conn, s.db, clone), drop: (s, clone) => dropQdrant(s.conn, clone) },
 };
+// Stores whose app names its databases in its code are copied as a whole server instead.
+const SERVER = { mongo: (s, name) => serveMongo(s.conn, name), elasticsearch: (s, name) => serveElastic(s.conn, name) };
 const TOOLS = { postgres: "Postgres's own psql and pg_dump are", mongo: "MongoDB's own mongodump, mongorestore and mongosh are" };
 
 const SCHEME = /^(postgres(?:ql)?|mysql|mariadb|mongodb|rediss?|valkeys?|sqlserver|mssql)((?:\+\w+)*):\/\/([^/?#]*)(\/[^?#]*)?([?#].*)?$/i;
 const SCHEME_ENGINE = { postgres: "postgres", postgresql: "postgres", mysql: "mysql", mariadb: "mysql", mongodb: "mongo", redis: "redis", rediss: "redis", valkey: "redis", valkeys: "redis", sqlserver: "sqlserver", mssql: "sqlserver" };
 // A search or vector store is named by what its setting is called, since it speaks plain HTTP.
-const BY_NAME = [["qdrant", /QDRANT/], ["chroma", /CHROMA/], ["milvus", /MILVUS|ZILLIZ/], ["weaviate", /WEAVIATE/], ["elasticsearch", /ELASTIC|OPENSEARCH/], ["meilisearch", /MEILI/], ["typesense", /TYPESENSE/], ["neo4j", /NEO4J/], ["supabase", /SUPABASE/]];
+const BY_NAME = [["qdrant", /QDRANT/], ["chroma", /CHROMA/], ["milvus", /MILVUS|ZILLIZ/], ["weaviate", /WEAVIATE/], ["elasticsearch", /ELASTIC|OPENSEARCH|^ES_/], ["meilisearch", /MEILI/], ["typesense", /TYPESENSE/], ["neo4j", /NEO4J/], ["supabase", /SUPABASE/]];
 const WORD_ENGINE = [["postgres", /^(?:PG|POSTGRES|PSQL)|POSTGRES/], ["mysql", /MYSQL|MARIA/], ["mongo", /MONGO/], ["redis", /REDIS|VALKEY/]];
 const SECRETISH = /(?:^|_)(?:KEY|TOKEN|SECRET|PASSWORD|PASS|PWD)$/;
 // Every engine's word in a setting's name, so a setting that carries one is that engine's own.
@@ -43,6 +48,7 @@ const ENGINE_WORD = new RegExp([...Object.keys(ENGINE), ...[...BY_NAME, ...WORD_
 // their own command is handed the rest: which databases it uses is that command's to say.
 const STORE_SETTING = new RegExp(`${ENGINE_WORD.source}|(?:^|_)(?:DB|DATABASE)(?:_|$)`, "i");
 export const withoutStoreSettings = (values) => Object.fromEntries(Object.entries(values).filter(([name]) => !STORE_SETTING.test(name)));
+export const storeSettings = (values) => Object.fromEntries(Object.entries(values).filter(([name]) => STORE_SETTING.test(name)));
 // Stores that hold no collections: a bare COLLECTION setting beside one of them is still Qdrant's.
 const NO_COLLECTIONS = new Set(["redis", "mysql", "sqlserver", "neo4j", "meilisearch", "pinecone"]);
 const LOOPBACK = /^(?:localhost|127(?:\.\d+){3}|::1|\[::1\]|0\.0\.0\.0|host\.docker\.internal)?$/i;
@@ -85,18 +91,38 @@ function fromUrl(name, value) {
     engine, host, port, db,
     conn: { host, port, user: a.user, password: a.password, sslmode: query.get("sslmode") ?? "", tlsOn: /^(?:rediss|valkeys)$/i.test(m[1]), uri: value },
     point: engine === "mongo" ? (to) => ({ [name]: withDb(value, to, db) }) : (to) => ({ [name]: `${m[1]}${m[2]}://${m[3]}/${encodeURIComponent(String(to))}${m[5] ?? ""}` }),
+    // The same address on another server: what a copy of the whole server is reached through.
+    move: (to, toPort) => ({ [name]: `${m[1]}${m[2]}://${m[3].slice(0, m[3].lastIndexOf("@") + 1)}${to}:${toPort}${m[4] ?? ""}${m[5] ?? ""}` }),
   };
 }
 
-// A search or vector store's address: QDRANT_URL=http://localhost:6333, MILVUS_URI=localhost:19530.
+// A search or vector store's address: QDRANT_URL=http://localhost:6333, MILVUS_URI=localhost:19530,
+// ELASTICSEARCH_URL=http://elastic:pw@localhost:9200.
 function fromNamed(name, value) {
   const engine = BY_NAME.find(([, re]) => re.test(name))?.[0];
   if (!engine || SECRETISH.test(name)) return null;
-  const m = /^(?:(https?|grpc|bolt|neo4j):\/\/)?([\w.-]+|\[[:\w]+\]):?(\d+)?(?:[/?#].*)?$/i.exec(value);
-  if (!m || (!m[1] && !m[3])) return null;
-  const host = m[2].replace(/^\[|\]$/g, "");
-  const port = m[3] ? Number(m[3]) : m[1] === "https" ? 443 : PORT_OF[engine] ?? 80;
-  return { engine, host, port, db: null, conn: { base: `${m[1] === "https" ? "https" : "http"}://${host.includes(":") ? `[${host}]` : host}:${port}` } };
+  const m = /^(?:(https?|grpc|bolt|neo4j):\/\/)?(?:([^@/\s]*)@)?([\w.-]+|\[[:\w]+\]):?(\d+)?([/?#].*)?$/i.exec(value);
+  if (!m || (!m[1] && !m[4])) return null;
+  const host = m[3].replace(/^\[|\]$/g, "");
+  const port = m[4] ? Number(m[4]) : m[1] === "https" ? 443 : PORT_OF[engine] ?? 80;
+  const [user, ...pass] = m[2] ? m[2].split(":") : [];
+  return {
+    engine, host, port, db: null,
+    conn: { base: `${m[1] === "https" ? "https" : "http"}://${host.includes(":") ? `[${host}]` : host}:${port}`, port, ...(user ? { user: dec(user), password: dec(pass.join(":")) } : {}) },
+    // A copy of the whole server speaks plain HTTP on this machine.
+    move: (to, toPort) => ({ [name]: `${m[1] ? "http://" : ""}${m[2] ? `${m[2]}@` : ""}${to}:${toPort}${m[5] ?? ""}` }),
+  };
+}
+
+// A search server's sign-in sits in settings beside its address: ELASTIC_PASSWORD, ES_API_KEY.
+const BY_NAME_ELASTIC = BY_NAME.find(([e]) => e === "elasticsearch")[1];
+function withLogin(store, values) {
+  if (store.conn.user) return store;
+  const own = (re) => values[Object.keys(values).find((n) => BY_NAME_ELASTIC.test(n) && re.test(n) && values[n])];
+  const apiKey = own(/API_?KEY$/);
+  const password = own(/(?:PASS|PASSWORD)$/);
+  if (apiKey) return { ...store, conn: { ...store.conn, apiKey } };
+  return password ? { ...store, conn: { ...store.conn, user: own(/USER(?:NAME)?$/) ?? "elastic", password } } : store;
 }
 
 // A vector store holds collections, and the app's settings name the ones it uses: QDRANT_COLLECTION,
@@ -116,6 +142,9 @@ function withCollections(store, values, others) {
   return named.map((n) => ({ ...store, conn, db: String(values[n]).trim(), names: [...store.names, n], point: (to) => ({ [n]: String(to) }) }));
 }
 
+// MongoDB's tools take one address: the parts' own, written as one.
+const mongoUri = (host, port, user, password) => `mongodb://${user ? `${encodeURIComponent(user)}:${encodeURIComponent(password ?? "")}@` : ""}${host || "127.0.0.1"}:${port}/`;
+
 // Settings that name one store in parts, grouped by what they share before the part:
 // POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB; DB_HOST, DB_NAME, DB_CONNECTION=pgsql; PGHOST, PGDATABASE.
 const HOST_PART = /^(.+?)_?(?:HOST(?:NAME)?|SERVER)$/;
@@ -148,10 +177,11 @@ function fromParts(values) {
     const db = parts.db ? (engine === "redis" ? Number(values[parts.db] || 0) : values[parts.db]) : engine === "redis" ? 0 : "";
     out.push({
       engine, host, port, db,
-      conn: { host, port, user: values[parts.user] ?? "", password: values[parts.password] ?? "", sslmode: p === "PG" ? values.PGSSLMODE ?? "" : "" },
+      conn: { host, port, user: values[parts.user] ?? "", password: values[parts.password] ?? "", sslmode: p === "PG" ? values.PGSSLMODE ?? "" : "", ...(engine === "mongo" ? { uri: mongoUri(host, port, values[parts.user], values[parts.password]) } : {}) },
       names: [hostName ?? parts.user ?? parts.port, parts.db].filter(Boolean),
       // Only a setting that holds the database can point the app at another one.
       point: parts.db ? (to) => ({ [parts.db]: String(to) }) : null,
+      move: !hostName ? null : parts.port ? (to, toPort) => ({ [hostName]: to, [parts.port]: String(toPort) }) : inline ? (to, toPort) => ({ [hostName]: `${to}:${toPort}` }) : null,
     });
   }
   return out;
@@ -173,11 +203,12 @@ export function storesOf(values) {
   }
   found.push(...fromParts(values));
   const engines = found.map((s) => s.engine);
-  const each = found.flatMap((s) => (s.engine === "qdrant" ? withCollections(s, values, engines) : [s]));
+  const each = found.flatMap((s) => (s.engine === "qdrant" ? withCollections(s, values, engines) : s.engine === "elasticsearch" ? [withLogin(s, values)] : [s]));
   const byKey = new Map();
   const merge = (held, s) => {
     held.names = [...new Set([...held.names, ...s.names])];
     if (s.point) held.points.push(s.point);
+    if (s.move) held.moves.push(s.move);
     held.conn ??= s.conn;
   };
   const whole = each.filter((s) => s.db !== "" && s.db !== null);
@@ -185,7 +216,7 @@ export function storesOf(values) {
     const key = `${at(s)}|${s.db ?? ""}`;
     const held = byKey.get(key) ?? (s.db === "" || s.db === null ? [...byKey.values()].find((h) => at(h) === at(s)) : undefined);
     if (held) { merge(held, s); continue; }
-    byKey.set(key, { ...s, key, points: s.point ? [s.point] : [] });
+    byKey.set(key, { ...s, key, points: s.point ? [s.point] : [], moves: s.move ? [s.move] : [] });
   }
   return [...byKey.values()];
 }
@@ -194,37 +225,39 @@ export function storesOf(values) {
 const listed = (names) => (names.length === 1 ? names[0] : names.length <= 3 ? `${names.slice(0, -1).join(", ")} and ${names.at(-1)}` : `${names.slice(0, 2).join(", ")} and ${names.length - 2} more settings`);
 const unit = (s) => (s.engine === "qdrant" ? "collection" : "database");
 const whatOf = (s) => (s.engine === "redis" ? `Redis database ${s.db}` : s.db ? `${ENGINE[s.engine]} ${unit(s)} ${s.db}` : `${ENGINE[s.engine]} server`);
-const copied = Object.keys(COPY).map((e) => ENGINE[e]);
+const copied = [...new Set([...Object.keys(COPY), ...Object.keys(SERVER)])].map((e) => ENGINE[e]);
 const copiedList = `${copied.slice(0, -1).join(", ")} and ${copied.at(-1)}`;
 
-// Why no copy was made, in a sentence of theirs, and what to do about it. The store's own words are
-// never quoted: they name users and hosts.
-const REASONS = {
-  auth: ["the password its settings carry was refused", "Check that setting before a run"],
-  rights: ["the user it signs in as may not create databases", "Give that user the right to create databases, or point it at a scratch database, before a run"],
-  down: ["nothing answered at the address its settings give", "Start it before a run"],
-  big: ["it is over the size a run copies", "Point it at a smaller scratch copy before a run if it holds real data"],
-  missing: [(s) => `${TOOLS[s.engine]} not on this machine's PATH`, (s) => `Install them, or point it at a scratch ${unit(s)}, before a run`],
-  version: ["this machine's copy of the store's own tools is older than the server", "Update them, or point it at a scratch database, before a run"],
-  oldServer: ["the server is older than Redis 6.2, which a copy needs", "Upgrade it, or point it at a scratch database, before a run"],
-  full: ["it has no empty database left to copy into", "Point it at a scratch database before a run if it holds real data"],
-  cluster: ["it runs as a cluster, which has one database only", "Point it at a scratch server before a run if it holds real data"],
-  other: ["the copy did not go through", "Point it at a scratch database before a run if it holds real data"],
+// Why no copy was made of a store on this machine, in a sentence of theirs, and the one thing to do.
+// The store's own words are never quoted: they name users and hosts.
+const HERE = {
+  started: () => ["your app was already running when this command started", "Stop your app"],
+  engine: (s) => [`we copy ${copiedList} for a run, not ${ENGINE[s.engine]}`, `Point ${s.names[0]} at a scratch ${s.db ? unit(s) : "server"}`],
+  fixed: (s) => [`no setting names its ${s.engine === "redis" ? "database number" : `${unit(s)} name`} to point the app at a copy`, `Put the ${s.engine === "redis" ? "database number" : `${unit(s)} name`} in a setting`],
+  auth: (s) => ["the password its settings carry was refused", `Check ${s.names[0]}`],
+  rights: () => ["the user it signs in as may not create databases", "Give that user the right to create databases"],
+  down: () => ["nothing answered at the address its settings give", "Start it"],
+  big: () => ["it is over the size a run copies", "Point it at a smaller scratch copy"],
+  missing: (s) => [`${TOOLS[s.engine] ?? "its own tools are"} not on this machine's PATH`, "Install them"],
+  version: () => ["this machine's copy of the store's own tools is older than the server", "Update them"],
+  oldServer: () => ["the server is older than Redis 6.2, which a copy needs", "Upgrade it"],
+  full: () => ["it has no empty database left to copy into", "Empty one of its databases"],
+  cluster: () => ["it runs as a cluster, which has one database only", "Point it at a scratch server"],
+  docker: () => ["a copy of it is made in Docker, which is not running on this machine", "Start Docker"],
+  login: (s) => ["your app signs in to it in a way a copy of it cannot be given", `Point ${s.names[0]} at a scratch server, or sign in with a user and password`],
+  container: () => ["Docker could not start a copy of it", "Check that Docker can pull and run its image"],
+  other: (s) => ["the copy did not go through", `Point ${s.names[0]} at a scratch ${s.db ? unit(s) : "server"}`],
 };
-const risk = (s, why) => {
-  const lead = `What test conversations create in the ${whatOf(s)} that ${listed(s.names)} ${s.names.length === 1 ? "names" : "name"} stays there`;
-  if (why === "started") return `${lead}: your app was already running when this command started. Stop it and run the command again to run against a copy.`;
-  if (why === "engine") return `${lead}: we copy ${copiedList} for a run, not ${ENGINE[s.engine]}. Point ${s.names[0]} at a scratch ${s.db ? unit(s) : "server"} before a run if that one holds real data.`;
-  if (why === "fixed" && s.engine === "qdrant") return `${lead}: its settings do not say which collection the app keeps there, so the app cannot be pointed at a copy. Point ${s.names[0]} at a scratch server before a run if that one holds real data.`;
-  if (why === "fixed") return `${lead}: the ${s.engine === "redis" ? "database number" : `${unit(s)} name`} is not among its settings, so the app cannot be pointed at a copy. Put it in one before a run if that one holds real data.`;
-  const [reason, fix] = (REASONS[why] ?? REASONS.other).map((w) => (typeof w === "function" ? w(s) : w));
-  return `${lead}: ${reason}, so no copy was made. ${fix}.`;
+const heldHere = (s, why) => {
+  const [reason, fix] = (HERE[why] ?? HERE.other)(s);
+  return `${listed(s.names)} ${s.names.length === 1 ? "points" : "point"} at the ${whatOf(s)} on this machine, and ${reason}, so test conversations would save into it. ${fix}, then run the connect command again.`;
 };
 const kept = (s, clone, how) => (s.engine === "redis"
   ? `Your app runs against a copy of its Redis data in database ${clone} of the same server, through ${listed(s.names)}; database ${s.db} is not touched, and database ${clone} is emptied when this command ends and copied again at the next connect.`
   : how === "empty"
     ? `Your app makes its ${ENGINE[s.engine]} ${unit(s)} ${s.db} under the name ${clone} on the same server, through ${listed(s.names)}; the server holds no ${s.db} yet, and ${clone} is deleted when this command ends and made again empty at the next connect.`
     : `Your app runs against a copy of its ${ENGINE[s.engine]} ${unit(s)} ${s.db}, made on the same server, through ${listed(s.names)}; the original is not touched, and the copy is deleted when this command ends and made again from the original at the next connect.`);
+const serverKept = (s) => `Your app runs against a copy of its whole ${ENGINE[s.engine]} server, made in a Docker container of ours, through ${listed(s.names)}; the original is not touched, and the container is deleted when this command ends and made again from the original at the next connect.`;
 
 // What holds Run for a store off this machine no copy could be made of, and the one thing to do.
 // The first reason is the most useful: a Neon store with no key says the key.
@@ -232,7 +265,7 @@ const HELD = {
   "neon-key": (s) => ["there is no NEON_API_KEY in its settings to make a branch with", `Set NEON_API_KEY, or point ${s.names[0]} at a database on this machine`],
   neon: (s) => ["Neon did not make a branch of it", `Check NEON_API_KEY, or point ${s.names[0]} at a database on this machine`],
   supabase: (s) => ["a local Supabase needs supabase/config.toml, Docker and the supabase command", `Add them, or point ${s.names[0]} at a local Supabase`],
-  engine: (s) => [`Cortad cannot copy a hosted ${ENGINE[s.engine]}`, `Point ${s.names[0]} at a ${ENGINE[s.engine]} on this machine`],
+  engine: (s) => [`no copy of a hosted ${ENGINE[s.engine]} is made`, `Point ${s.names[0]} at a ${ENGINE[s.engine]} on this machine`],
   parts: (s) => ["its settings name it in parts, which cannot be pointed at a copy", `Put its whole address in one setting, or point ${s.names[0]} at a database on this machine`],
   "no-migrations": (s) => ["no migrations were found to build a copy on this machine from", `Point ${s.names[0]} at a database on this machine`],
   "no-local": (s) => ["no Postgres on this machine let us make a database to build a copy in", "Start Postgres on this machine"],
@@ -247,12 +280,12 @@ const HELD = {
 // card told the owner, on the card, that "the owner can say yes to it on the card in the browser".
 const heldWhy = (s, why, tool) => {
   const [reason, fix] = (HELD[why] ?? HELD.other)(s, tool);
-  return `${listed(s.names)} ${s.names.length === 1 ? "points" : "point"} at ${s.engine === "redis" || s.db ? "the" : "a"} ${whatOf(s)} off this machine, and ${reason}, so the run would write into it as it is. ${fix}, then run the connect command again.`;
+  return `${listed(s.names)} ${s.names.length === 1 ? "points" : "point"} at ${s.engine === "redis" || s.db ? "the" : "a"} ${whatOf(s)} that is not on this machine, and ${reason}, so test conversations would save into it. ${fix}, then run the connect command again.`;
 };
 // A Qdrant server the app writes into is kept by the hook in the app instead of by a copy made here:
 // the first write a run makes into a collection copies that collection on the same server and the
 // app's later calls go to the copy (lib/trace.cjs, lib/pyhook/sitecustomize.py). So a hosted Qdrant
-// holds nothing, and a local one whose collection no setting names is not a risk either.
+// holds nothing, and neither does a local one whose collection no setting names.
 export const GUARDED_ENGINES = new Set(["qdrant"]);
 const guardedKept = (s) => `Your app's ${ENGINE[s.engine]} collections at ${listed(s.names)} are not written into by a run: the first time a run writes into one, that collection is copied on the same server and the app's calls go to the copy, which is deleted when this command ends.`;
 const hostedKept = (s, got) => (got.how === "neon"
@@ -271,13 +304,17 @@ export const bypassedOf = (connections, stores, blocked) => stores
 // A copy that throws is one that did not go through, said as such; it never stops the app starting.
 const drop = (s, clone, marker) => COPY[s.engine].drop(s, clone, marker).catch(() => false);
 const copy = (s, clone, marker) => COPY[s.engine].copy(s, clone, marker).catch(() => ({ why: "other" }));
+const serve = (s, name) => SERVER[s.engine](s, name).catch(() => ({ why: "other" }));
+const undo = (s, row) => (row.kind === "server" ? removeCopy(row.made) : drop(s, row.made, row.marker));
 const cloneName = (db) => `${String(db).slice(0, 40)}_cortad_${process.pid}`;
+// Refusals a copy of the whole server would meet the same way.
+const SERVER_TOO = new Set(["auth", "big", "down"]);
 
 // One session's copies. keep() copies the stores given that answer and says what it did; a store
 // nothing answers at yet is left out, unsaid, since trials cannot write into it: once it is started
 // (lib/backing.mjs), keep() is asked again for it. drop() deletes every copy, and copies a session
-// that died left behind are deleted by the next one, through the ledger. A store off this machine
-// with no copy is `blocked`, and `pass` names the hosts of the copies made off it.
+// that died left behind are deleted by the next one, through the ledger. A store with no copy is
+// `blocked`, and `pass` names the hosts of the copies made off this machine.
 // `values`, `dirs`, `fetchFn` and `local` are lib/hosted.mjs's.
 export function storeKeeper({ ledgerFile, values = {}, dirs = [], fetchFn, local }) {
   const book = ledger(ledgerFile);
@@ -290,9 +327,9 @@ export function storeKeeper({ ledgerFile, values = {}, dirs = [], fetchFn, local
         const s = stores.find((x) => x.key === row.key);
         if (s && (await drop(s, row.made, row.marker))) book.remove(row);
       }
+      for (const row of book.orphans("server")) if (await removeCopy(row.made)) book.remove(row);
       await hosted.orphans();
       const env = {};
-      const risks = [];
       const copies = [];
       const blocked = [];
       const pass = [];
@@ -315,30 +352,48 @@ export function storeKeeper({ ledgerFile, values = {}, dirs = [], fetchFn, local
         }
         if (await down(s)) continue;
         done.add(s.key);
-        if (!started) { risks.push(risk(s, "started")); continue; }
-        if (!COPY[s.engine]) { risks.push(risk(s, "engine")); continue; }
-        if (!s.points.length || (s.engine !== "redis" && !s.db)) { risks.push(risk(s, "fixed")); continue; }
-        const marker = `${process.pid}-${Date.now()}`;
-        // Recorded before the copy starts, so a session killed mid-copy leaves a row the next one
-        // undoes. A Redis copy's database is found by its marker then.
-        const row = { kind: "copy", key: s.key, made: s.engine === "redis" ? null : cloneName(s.db), marker };
-        book.add(row);
-        const got = await copy(s, cloneName(s.db), marker);
-        if (got.why) {
+        if (!started) { blocked.push({ id: storeId(s), names: s.names, why: heldHere(s, "started") }); continue; }
+        let why = !COPY[s.engine] ? "engine" : !s.points.length || (s.engine !== "redis" && !s.db) ? "fixed" : null;
+        if (!why) {
+          const marker = `${process.pid}-${Date.now()}`;
+          // Recorded before the copy starts, so a session killed mid-copy leaves a row the next one
+          // undoes. A Redis copy's database is found by its marker then.
+          const row = { kind: "copy", key: s.key, made: s.engine === "redis" ? null : cloneName(s.db), marker };
+          book.add(row);
+          const got = await copy(s, cloneName(s.db), marker);
+          if (!got.why) {
+            const clone = got.index ?? cloneName(s.db);
+            made.push({ s, row });
+            for (const point of s.points) Object.assign(env, point(clone));
+            copies.push(kept(s, clone, got.how));
+            continue;
+          }
           if (await drop(s, row.made, marker)) book.remove(row);
           // A database the server does not hold is one trials cannot write into.
-          if (got.why !== "gone") risks.push(risk(s, got.why));
-          continue;
+          if (got.why === "gone") continue;
+          why = got.why;
+        }
+        // The app names its databases in its code, or this machine lacks the store's own tools: the
+        // whole server is copied into a container of ours and the app's address moved to it.
+        if (SERVER[s.engine] && s.moves.length && !SERVER_TOO.has(why)) {
+          const row = { kind: "server", key: s.key, made: copyName(s.engine) };
+          book.add(row);
+          const got = await serve(s, row.made);
+          if (got.port) {
+            made.push({ s, row });
+            for (const move of s.moves) Object.assign(env, move("127.0.0.1", got.port));
+            copies.push(serverKept(s));
+            continue;
+          }
+          if (await removeCopy(row.made)) book.remove(row);
+          why = got.why;
         }
-        const clone = got.index ?? cloneName(s.db);
-        made.push({ s, row });
-        for (const point of s.points) Object.assign(env, point(clone));
-        copies.push(kept(s, clone, got.how));
+        blocked.push({ id: storeId(s), names: s.names, why: heldHere(s, why) });
       }
-      return { env, risks, copies, blocked, pass };
+      return { env, copies, blocked, pass };
     },
     drop: async () => {
-      for (const { s, row } of made.splice(0)) if (await drop(s, row.made, row.marker)) book.remove(row);
+      for (const { s, row } of made.splice(0)) if (await undo(s, row)) book.remove(row);
       await hosted.drop();
     },
     // The collections the hook in the app copied for a run's writes (lib/trace.cjs copyOf), deleted