robodev 0.29.0 → 0.31.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "robodev",
-  "version": "0.29.0",
-  "description": "CLI for Robodev Starbase — create, auth, link, and deploy hosted apps",
+  "version": "0.31.0",
+  "description": "CLI for Robodev Starbase — create, auth, link, deploy, and run a project locally with robodev dev",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -20,17 +20,21 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "robodev": "tsx src/index.ts",
-    "generate:templates": "tsx src/generate-templates.ts",
-    "prepack": "tsx src/generate-templates.ts",
-    "test": "tsx --test src/**/*.test.ts"
-  },
   "dependencies": {
-    "tsx": "^4.20.5"
+    "@fastify/cors": "^11.3.0",
+    "embedded-postgres": "17.10.0-beta.17",
+    "fastify": "^5.12.1",
+    "tsx": "^4.20.5",
+    "@robodev-ai/runtime": "0.1.0",
+    "@robodev-ai/sdk": "0.10.0"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",
     "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "robodev": "tsx src/index.ts",
+    "generate:templates": "tsx src/generate-templates.ts",
+    "test": "tsx --test src/**/*.test.ts"
   }
-}
+}

package/src/collect-files.test.ts

@@ -4,7 +4,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
-import { collectFiles, mergeCollectedFiles } from "./collect-files.js";
+import { collectFiles, mergeCollectedFiles, shouldCollectPath } from "./collect-files.js";
 
 test("collectFiles includes hosted sources and skips denied paths", async () => {
   const root = await mkdtemp(join(tmpdir(), "rd-cli-"));
@@ -57,6 +57,22 @@ test("collectFiles includes hosted sources and skips denied paths", async () =>
   }
 });
 
+test("collectFiles includes public SPA binaries as base64", async () => {
+  const root = await mkdtemp(join(tmpdir(), "rd-cli-bin-"));
+  try {
+    await writeFile(join(root, "database.ts"), "export default {}");
+    await mkdir(join(root, "public/assets"), { recursive: true });
+    await writeFile(join(root, "public/assets/font.woff2"), Buffer.from("woff2-bytes"));
+    await writeFile(join(root, "public/icon.png"), Buffer.from("png-bytes"));
+    const files = await collectFiles(root);
+    const byPath = Object.fromEntries(files.map((file) => [file.path, file.content]));
+    assert.equal(byPath["public/assets/font.woff2"], Buffer.from("woff2-bytes").toString("base64"));
+    assert.equal(byPath["public/icon.png"], Buffer.from("png-bytes").toString("base64"));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("collectFiles still accepts a legacy root database.ts tree", async () => {
   const root = await mkdtemp(join(tmpdir(), "rd-cli-"));
   try {
@@ -146,3 +162,12 @@ test("collectFiles rejects mixed backend layouts", async () => {
     await rm(root, { recursive: true, force: true });
   }
 });
+
+test("backend tests are not collected for deploy", () => {
+  assert.equal(shouldCollectPath("robodev/api/_lib.seed.test.ts"), false);
+  assert.equal(shouldCollectPath("robodev/jobs/resize.spec.ts"), false);
+  assert.equal(shouldCollectPath("robodev/sockets/chat.test.ts"), false);
+  assert.equal(shouldCollectPath("api/health.test.ts"), false);
+  assert.equal(shouldCollectPath("robodev/api/_lib.ts"), true);
+  assert.equal(shouldCollectPath("robodev/api/latest.ts"), true);
+});

package/src/collect-files.ts

@@ -1,11 +1,11 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join, relative } from "node:path";
 
-export const MAX_FILE_COUNT = 200;
+export const MAX_FILE_COUNT = 400;
 export const MAX_FILE_BYTES = 1024 * 1024;
-/** Hashed Vite JS from Tiny can exceed 1MB; keep API/source at 1MB. */
-export const MAX_STATIC_FILE_BYTES = 4 * 1024 * 1024;
-export const MAX_TREE_BYTES = 15 * 1024 * 1024;
+/** Hashed Vite JS and SPA fonts from Tiny can exceed 1MB; keep API/source at 1MB. */
+export const MAX_STATIC_FILE_BYTES = 8 * 1024 * 1024;
+export const MAX_TREE_BYTES = 25 * 1024 * 1024;
 export const MAX_PATH_LENGTH = 240;
 export const MAX_PATH_DEPTH = 12;
 
@@ -33,6 +33,18 @@ const BINARY_EXTENSIONS = new Set([
   ".webm",
   ".mp3",
 ]);
+const PUBLIC_BINARY_EXTENSIONS = new Set([
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+]);
 const SRC_EXTENSIONS = new Set([
   ".ts",
   ".tsx",
@@ -102,10 +114,20 @@ function isDenied(path: string): boolean {
   if (isRobodevLockfile(path)) return true;
   const name = basename(path);
   if (name.startsWith(".") && name !== ".gitignore") return true;
-  if (BINARY_EXTENSIONS.has(extname(path))) return true;
+  if (BINARY_EXTENSIONS.has(extname(path)) && !isPublicBinaryCollectedPath(path)) return true;
   return false;
 }
 
+export function isPublicBinaryCollectedPath(path: string): boolean {
+  const normalized = normalize(path);
+  return normalized.startsWith("public/") && PUBLIC_BINARY_EXTENSIONS.has(extname(normalized));
+}
+
+/** Project tests live beside the handlers they cover; they are not part of the deployed tree. */
+function isBackendTestPath(path: string): boolean {
+  return /\.(test|spec)\.ts$/.test(path);
+}
+
 function isBackendPath(path: string): boolean {
   const inner = path.startsWith("robodev/") ? path.slice("robodev/".length) : path;
   if (inner === "database.ts" && (path === "database.ts" || path === "robodev/database.ts")) {
@@ -117,7 +139,7 @@ function isBackendPath(path: string): boolean {
     inner.startsWith("hooks/") ||
     inner.startsWith("sockets/")
   ) {
-    return inner.endsWith(".ts");
+    return inner.endsWith(".ts") && !isBackendTestPath(inner);
   }
   return path === "robodev/package.json";
 }
@@ -127,7 +149,9 @@ function isAllowed(path: string): boolean {
   if (path.startsWith("robodev/")) return false;
   if (path === "index.html") return true;
   if (path.startsWith("src/")) return SRC_EXTENSIONS.has(extname(path));
-  if (path.startsWith("public/")) return PUBLIC_EXTENSIONS.has(extname(path));
+  if (path.startsWith("public/")) {
+    return PUBLIC_EXTENSIONS.has(extname(path)) || PUBLIC_BINARY_EXTENSIONS.has(extname(path));
+  }
   if (CONFIG_FILES.has(path) || CONFIG_FILES.has(basename(path))) return true;
   if (/^tsconfig\..+\.json$/.test(basename(path)) && !path.includes("/")) return true;
   if (!path.includes("/") && ROOT_STATIC_EXTENSIONS.has(extname(path))) return true;
@@ -177,6 +201,20 @@ function formatMaxBytes(bytes: number): string {
   return `${Math.round(bytes / (1024 * 1024))}MB`;
 }
 
+export function collectedFileStoredBytes(file: CollectedFile): number {
+  if (isPublicBinaryCollectedPath(file.path)) {
+    return Buffer.from(file.content, "base64").byteLength;
+  }
+  return Buffer.byteLength(file.content, "utf8");
+}
+
+export async function readCollectedContent(abs: string, deployPath: string): Promise<string> {
+  if (isPublicBinaryCollectedPath(deployPath)) {
+    return (await readFile(abs)).toString("base64");
+  }
+  return readFile(abs, "utf8");
+}
+
 export function assertCollectedFile(file: CollectedFile): void {
   const path = normalize(file.path);
   if (
@@ -187,7 +225,7 @@ export function assertCollectedFile(file: CollectedFile): void {
   ) {
     throw new Error(`Invalid file path: ${path}`);
   }
-  const bytes = Buffer.byteLength(file.content, "utf8");
+  const bytes = collectedFileStoredBytes(file);
   const max = maxBytesForCollectedPath(path);
   if (bytes > max) {
     throw new Error(`File must be under ${formatMaxBytes(max)}: ${path}`);
@@ -203,7 +241,7 @@ export function assertCollectedLimits(files: CollectedFile[]): void {
     assertCollectedFile(file);
     totalBytes += Buffer.byteLength(file.content, "utf8");
     if (totalBytes > MAX_TREE_BYTES) {
-      throw new Error("Deploy tree must be under 15MB");
+      throw new Error(`Deploy tree must be under ${formatMaxBytes(MAX_TREE_BYTES)}`);
     }
   }
 }
@@ -251,15 +289,15 @@ export async function collectFiles(root: string): Promise<CollectedFile[]> {
       if (path.length > MAX_PATH_LENGTH || path.split("/").length > MAX_PATH_DEPTH) {
         throw new Error(`Invalid file path: ${path}`);
       }
-      const content = await readFile(abs, "utf8");
-      const bytes = Buffer.byteLength(content, "utf8");
+      const content = await readCollectedContent(abs, path);
+      const bytes = collectedFileStoredBytes({ path, content });
       const max = maxBytesForCollectedPath(path);
       if (bytes > max) {
         throw new Error(`File must be under ${formatMaxBytes(max)}: ${path}`);
       }
-      totalBytes += bytes;
+      totalBytes += Buffer.byteLength(content, "utf8");
       if (totalBytes > MAX_TREE_BYTES) {
-        throw new Error("Deploy tree must be under 15MB");
+        throw new Error(`Deploy tree must be under ${formatMaxBytes(MAX_TREE_BYTES)}`);
       }
       files.push({ path, content });
       if (files.length > MAX_FILE_COUNT) {

package/src/dev-clients.ts

@@ -0,0 +1,65 @@
+import type { RouteClients } from "@robodev-ai/runtime";
+import type { EmailClient, LlmClient } from "@robodev-ai/sdk";
+
+/**
+ * The `ctx.*` clients `robodev dev` can offer offline. `email` prints to the terminal;
+ * everything that needs Starbase infrastructure fails with a message that says so rather
+ * than silently doing nothing.
+ */
+
+function unavailable(feature: string): never {
+  throw Object.assign(
+    new Error(`ctx.${feature} needs hosted Starbase. Run robodev deploy to use it.`),
+    { statusCode: 501 },
+  );
+}
+
+/** Prints mail to stdout so local signup and reset flows are followable. */
+export function consoleEmailClient(log: (line: string) => void): EmailClient {
+  return {
+    async send(input) {
+      const to = Array.isArray(input.to) ? input.to.join(", ") : input.to;
+      log(`email → ${to}: ${input.subject}`);
+      if (input.text) log(`  ${input.text}`);
+      return { id: `local_${Date.now().toString(36)}`, status: "sent" };
+    },
+  };
+}
+
+function offlineLlmClient(): LlmClient {
+  return {
+    complete: () => unavailable("llm"),
+    stream: () => unavailable("llm"),
+  };
+}
+
+export function devRouteClients(input: {
+  env: Record<string, string>;
+  log: (line: string) => void;
+}): RouteClients {
+  return {
+    email: consoleEmailClient(input.log),
+    llm: offlineLlmClient(),
+    agent: {
+      createSession: () => unavailable("agent"),
+      start: () => unavailable("agent"),
+      events: () => unavailable("agent"),
+      subscribe: () => unavailable("agent"),
+      destroy: () => unavailable("agent"),
+    },
+    storage: {
+      upload: () => unavailable("storage"),
+      get: () => unavailable("storage"),
+      getUrl: () => unavailable("storage"),
+      delete: () => unavailable("storage"),
+      list: () => unavailable("storage"),
+    },
+    push: { send: () => unavailable("push") },
+    jobs: { enqueue: () => unavailable("jobs") },
+    sockets: {
+      send: () => unavailable("sockets"),
+      broadcast: () => unavailable("sockets"),
+    },
+    env: input.env,
+  };
+}

package/src/dev-postgres.ts

@@ -0,0 +1,161 @@
+import { createServer } from "node:net";
+import { lstat, mkdir, readdir, readFile, symlink } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join, relative } from "node:path";
+import { arch, platform } from "node:os";
+
+export type DevPostgres = {
+  host: string;
+  port: number;
+  dataDir: string;
+  database: string;
+  connectionString: string;
+  stop: () => Promise<void>;
+};
+
+const DEV_USER = "robodev";
+const DEV_PASSWORD = "robodev";
+const DEV_DATABASE = "robodev";
+
+/** Asks the OS for a free TCP port so parallel projects never collide. */
+export async function freePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.unref();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        reject(new Error("Could not reserve a port for Postgres"));
+        return;
+      }
+      const { port } = address;
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+export function devConnectionString(input: { port: number; database?: string }): string {
+  return `postgres://${DEV_USER}:${DEV_PASSWORD}@127.0.0.1:${input.port}/${
+    input.database ?? DEV_DATABASE
+  }`;
+}
+
+async function isInitialised(dataDir: string): Promise<boolean> {
+  try {
+    return (await readdir(dataDir)).includes("PG_VERSION");
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The `@embedded-postgres/*` tarballs ship dylibs/shared objects without their version
+ * symlinks (npm tarballs cannot carry symlinks) and rebuild them from `pg-symlinks.json`
+ * in a `postinstall`. Package managers that skip install scripts leave the cluster
+ * unlaunchable with a cryptic loader error, so hydrate any missing links ourselves.
+ */
+export async function hydratePostgresSymlinks(): Promise<void> {
+  const pkg = `@embedded-postgres/${platform() === "win32" ? "windows" : platform()}-${arch()}`;
+  let pkgRoot: string;
+  try {
+    // The package only exports its entry point, so derive the root from `dist/index.js`.
+    pkgRoot = dirname(dirname(createRequire(import.meta.url).resolve(pkg)));
+  } catch {
+    return;
+  }
+
+  let entries: { source: string; target: string }[];
+  try {
+    entries = JSON.parse(
+      await readFile(join(pkgRoot, "native", "pg-symlinks.json"), "utf8"),
+    ) as typeof entries;
+  } catch {
+    return;
+  }
+
+  for (const entry of entries) {
+    const target = join(pkgRoot, entry.target);
+    try {
+      await lstat(target);
+      continue;
+    } catch {
+      /* missing, create it below */
+    }
+    try {
+      await symlink(relative(dirname(target), join(pkgRoot, entry.source)), target);
+    } catch {
+      /* another process won the race, or the tree is read-only */
+    }
+  }
+}
+
+async function loadEmbeddedPostgres() {
+  try {
+    const mod = await import("embedded-postgres");
+    return mod.default;
+  } catch (error) {
+    throw new Error(
+      `Could not load the embedded Postgres binaries (${
+        error instanceof Error ? error.message : String(error)
+      }). Reinstall dependencies, or point robodev dev at your own server with --database-url.`,
+    );
+  }
+}
+
+/**
+ * Starts a real Postgres on a free port with its cluster under `dataDir`, so rows survive
+ * restarts. `initdb` only runs the first time.
+ */
+export async function startDevPostgres(input: {
+  dataDir: string;
+  port?: number;
+  quiet?: boolean;
+}): Promise<DevPostgres> {
+  await hydratePostgresSymlinks();
+  const EmbeddedPostgres = await loadEmbeddedPostgres();
+  const port = input.port && input.port > 0 ? input.port : await freePort();
+  await mkdir(input.dataDir, { recursive: true });
+  const fresh = !(await isInitialised(input.dataDir));
+
+  const postgres = new EmbeddedPostgres({
+    databaseDir: input.dataDir,
+    port,
+    user: DEV_USER,
+    password: DEV_PASSWORD,
+    persistent: true,
+    onLog: input.quiet ? () => undefined : (message) => process.stderr.write(`${message}\n`),
+    onError: input.quiet ? () => undefined : (message) => process.stderr.write(`${message}\n`),
+  });
+
+  if (fresh) {
+    await postgres.initialise();
+  }
+  await postgres.start();
+  if (fresh) {
+    await postgres.createDatabase(DEV_DATABASE);
+  }
+
+  return {
+    host: "127.0.0.1",
+    port,
+    dataDir: input.dataDir,
+    database: DEV_DATABASE,
+    connectionString: devConnectionString({ port }),
+    stop: () => postgres.stop(),
+  };
+}
+
+/** Wraps a Postgres the user already runs, so `--database-url` behaves like the embedded one. */
+export function externalDevPostgres(connectionString: string): DevPostgres {
+  const url = new URL(connectionString);
+  return {
+    host: url.hostname,
+    port: Number(url.port || 5432),
+    dataDir: "",
+    database: url.pathname.replace(/^\//, "") || "postgres",
+    connectionString,
+    stop: async () => undefined,
+  };
+}

package/src/dev-project.test.ts

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import {
+  backendCandidates,
+  collectBackendFiles,
+  devDirFor,
+  findDevProject,
+  isBackendDevPath,
+} from "./dev-project.js";
+import { parseDevArgs, parseEnvFile } from "./dev.js";
+import { devConnectionString } from "./dev-postgres.js";
+
+async function tempProject(): Promise<string> {
+  return mkdtemp(join(tmpdir(), "robodev-dev-"));
+}
+
+const DATABASE_TS = `import { defineDatabase, pgTable, text } from "@robodev-ai/sdk";
+export const notes = pgTable("notes", { id: text("id").primaryKey() });
+export default defineDatabase({ name: "app", tables: { notes } });
+`;
+
+test("backendCandidates prefers robodev/ then the root then packages/be", () => {
+  assert.deepEqual(
+    backendCandidates("/p").map((entry) => entry.layout),
+    ["robodev", "root", "packages/be"],
+  );
+});
+
+test("findDevProject finds a robodev/ backend", async () => {
+  const root = await tempProject();
+  await mkdir(join(root, "robodev"), { recursive: true });
+  await writeFile(join(root, "robodev", "database.ts"), DATABASE_TS);
+
+  const project = await findDevProject(root);
+  assert.equal(project.root, root);
+  assert.equal(project.backendDir, join(root, "robodev"));
+  assert.equal(project.layout, "robodev");
+});
+
+test("findDevProject finds Tiny's packages/be and walks up from a subdirectory", async () => {
+  const root = await tempProject();
+  await mkdir(join(root, "packages", "be"), { recursive: true });
+  await mkdir(join(root, "apps", "fe"), { recursive: true });
+  await writeFile(join(root, "packages", "be", "database.ts"), DATABASE_TS);
+
+  const project = await findDevProject(join(root, "apps", "fe"));
+  assert.equal(project.root, root);
+  assert.equal(project.backendDir, join(root, "packages", "be"));
+  assert.equal(project.layout, "packages/be");
+});
+
+test("findDevProject explains itself when there is no project", async () => {
+  const root = await mkdtemp(join(tmpdir(), "robodev-empty-"));
+  await assert.rejects(() => findDevProject(root), /No database\.ts found/);
+});
+
+test("isBackendDevPath accepts backend sources only", () => {
+  assert.equal(isBackendDevPath("database.ts"), true);
+  assert.equal(isBackendDevPath("api/planets.ts"), true);
+  assert.equal(isBackendDevPath("api/planets/[id].ts"), true);
+  assert.equal(isBackendDevPath("jobs/digest.ts"), true);
+  assert.equal(isBackendDevPath("hooks/auth.ts"), true);
+  assert.equal(isBackendDevPath("sockets/chat.ts"), true);
+  assert.equal(isBackendDevPath("src/main.tsx"), false);
+  assert.equal(isBackendDevPath("api/planets.js"), false);
+  assert.equal(isBackendDevPath("package.json"), false);
+  assert.equal(isBackendDevPath("../secrets.ts"), false);
+  // Project tests stay out of the dev tree, exactly as deploy excludes them.
+  assert.equal(isBackendDevPath("api/_lib.seed.test.ts"), false);
+  assert.equal(isBackendDevPath("api/planets.spec.ts"), false);
+});
+
+test("collectBackendFiles reads deploy-shaped paths and skips the rest", async () => {
+  const root = await tempProject();
+  const backend = join(root, "robodev");
+  await mkdir(join(backend, "api", "planets"), { recursive: true });
+  await mkdir(join(backend, "jobs"), { recursive: true });
+  await mkdir(join(backend, "node_modules"), { recursive: true });
+  await writeFile(join(backend, "database.ts"), DATABASE_TS);
+  await writeFile(join(backend, "api", "planets.ts"), "export const get = 1;");
+  await writeFile(join(backend, "api", "planets", "[id].ts"), "export const get = 1;");
+  await writeFile(join(backend, "api", "notes.md"), "ignored");
+  await writeFile(join(backend, "api", "_lib.seed.test.ts"), "ignored");
+  await writeFile(join(backend, "jobs", "digest.ts"), "export default 1;");
+  await writeFile(join(backend, "node_modules", "x.ts"), "ignored");
+  await writeFile(join(backend, "package.json"), "{}");
+
+  const files = await collectBackendFiles(backend);
+  assert.deepEqual(files.map((file) => file.path).sort(), [
+    "api/planets.ts",
+    "api/planets/[id].ts",
+    "database.ts",
+    "jobs/digest.ts",
+  ]);
+});
+
+test("collectBackendFiles requires database.ts", async () => {
+  const root = await tempProject();
+  await mkdir(join(root, "api"), { recursive: true });
+  await writeFile(join(root, "api", "planets.ts"), "export const get = 1;");
+  await assert.rejects(() => collectBackendFiles(root), /database\.ts not found/);
+});
+
+test("devDirFor sidesteps a legacy .robodev link file", async () => {
+  const withDir = await tempProject();
+  assert.equal(await devDirFor(withDir), join(withDir, ".robodev", "dev"));
+
+  const withFile = await tempProject();
+  await writeFile(join(withFile, ".robodev"), "{}");
+  assert.equal(await devDirFor(withFile), join(withFile, ".robodev-dev"));
+});
+
+test("parseDevArgs defaults to :4000, an ephemeral db port, and watching", () => {
+  assert.deepEqual(parseDevArgs([]), {
+    port: 4000,
+    dbPort: 0,
+    force: false,
+    watch: true,
+    withFe: false,
+    databaseUrl: undefined,
+  });
+});
+
+test("parseDevArgs reads every flag", () => {
+  const parsed = parseDevArgs([
+    "--port",
+    "4500",
+    "--db-port",
+    "55433",
+    "--force",
+    "--no-watch",
+    "--with-fe",
+    "--database-url",
+    "postgres://u:p@localhost:5432/app",
+  ]);
+  assert.deepEqual(parsed, {
+    port: 4500,
+    dbPort: 55433,
+    force: true,
+    watch: false,
+    withFe: true,
+    databaseUrl: "postgres://u:p@localhost:5432/app",
+  });
+});
+
+test("parseDevArgs rejects malformed flag values", () => {
+  assert.throws(() => parseDevArgs(["--port", "abc"]), /--port needs/);
+  assert.throws(() => parseDevArgs(["--port", "-1"]), /--port needs/);
+  assert.throws(() => parseDevArgs(["--database-url"]), /--database-url needs/);
+  assert.throws(() => parseDevArgs(["--database-url", "--force"]), /--database-url needs/);
+});
+
+test("parseEnvFile handles comments, blanks, quotes, and values with =", () => {
+  assert.deepEqual(
+    parseEnvFile(["# comment", "", "A=1", 'B="two"', "C='three'", "D=a=b", "  E = 5 "].join("\n")),
+    { A: "1", B: "two", C: "three", D: "a=b", E: "5" },
+  );
+});
+
+test("devConnectionString points at loopback", () => {
+  assert.equal(
+    devConnectionString({ port: 55433 }),
+    "postgres://robodev:robodev@127.0.0.1:55433/robodev",
+  );
+});