okengine 0.10.2 → 0.11.0

package/src/cli/dev.test.ts

@@ -7,15 +7,19 @@
  */
 
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtemp } from "node:fs/promises";
+import { mkdir, mkdtemp, readdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import {
+  ADOPT_BARREL_FILE,
+  generateAdoptBarrel,
+  writeAdoptBarrel,
+} from "../compiler/generate-adopt.ts";
 import type { Manifest } from "../manifest/types.ts";
 import type { WideEvent } from "../runs/types.ts";
 import { isDataEnvelope, MCP_DATA_KIND } from "../mcp/data.ts";
 import { mintMcpSession } from "../mcp/session.ts";
 import { runDev, type DevOptions, type DevSession } from "./dev.ts";
-import { readDevMode, writeDevMode } from "./dev-mode.ts";
 import { mcpContextFromConsole } from "./mcp-from-console.ts";
 
 /** Repo public entry — absolute import so temp apps need no install. */
@@ -23,6 +27,45 @@ const OKE_INDEX = resolve(import.meta.dir, "../index.ts");
 
 const SECRET = "oke-dev-mcp-integration-secret";
 
+/** Minimal compose injectables — unit tests never shell out to Docker. */
+const STUB_IMAGES = {
+  "store.sql": "postgres:16-alpine",
+  "store.kv": "redis:7-alpine",
+} as const;
+const STUB_CREDENTIALS = {
+  "store.sql": {
+    user: "oke",
+    password: "test-password-not-in-yaml",
+    database: "oke",
+  },
+} as const;
+
+function stubCompose(
+  overrides: Partial<
+    Pick<
+      DevOptions,
+      "images" | "credentials" | "composeUp" | "composeHealth" | "composeStop" | "noDbPush"
+    >
+  > = {},
+): Pick<
+  DevOptions,
+  "images" | "credentials" | "composeUp" | "composeHealth" | "composeStop" | "noDbPush"
+> {
+  return {
+    images: STUB_IMAGES,
+    credentials: STUB_CREDENTIALS,
+    composeUp: async () => {},
+    composeHealth: async () =>
+      new Map([
+        ["store-sql", "ready"],
+        ["store-kv", "ready"],
+      ]),
+    composeStop: () => {},
+    noDbPush: true,
+    ...overrides,
+  };
+}
+
 const LIVE_MANIFEST: Manifest = {
   oke: "1.0",
   app: "dev-live",
@@ -72,6 +115,52 @@ describe("mcpContextFromConsole", () => {
   });
 });
 
+/**
+ * Console for MCP tests — boot with `docker: false` so host `OKE_DOCKER=1`
+ * from compose stubs does not force redis/smtp docker URLs.
+ */
+async function serveTestConsole(
+  port: number,
+  cwd: string,
+  manifest: Manifest = LIVE_MANIFEST,
+): Promise<{
+  readonly console: import("../console/server/app.ts").ConsoleAppHandle;
+  readonly port: number;
+  readonly stop: () => void;
+}> {
+  const { createConsoleApp } = await import("../console/server/app.ts");
+  const handle = createConsoleApp({
+    cwd,
+    secret: SECRET,
+    silentClaim: true,
+    manifest,
+  });
+  await handle.app.boot({ env: "test", docker: false });
+  handle.state.listRuns = async () => {
+    const runs = handle.app.bootResult?.runs;
+    if (!runs) return [];
+    return runs.all();
+  };
+  const server = Bun.serve({
+    port,
+    hostname: "127.0.0.1",
+    fetch: (req) => handle.app.fetch(req),
+  });
+  const boundPort = server.port;
+  if (boundPort === undefined) {
+    server.stop(true);
+    throw new Error("test console: Bun.serve did not bind a port");
+  }
+  return {
+    console: handle,
+    port: boundPort,
+    stop() {
+      server.stop(true);
+      void handle.app.stop();
+    },
+  };
+}
+
 describe("oke dev MCP live wiring", () => {
   let session: DevSession | undefined;
 
@@ -94,9 +183,11 @@ describe("oke dev MCP live wiring", () => {
       consolePort: 0,
       mcpPort: 0,
       appPort: 0,
+      ...stubCompose(),
       startApp: async () => ({ stop() {} }),
       regenClient: async () => {},
       write: () => {},
+      serveConsole: async (port) => serveTestConsole(port, dir),
     });
 
     expect(result.code).toBe(0);
@@ -223,26 +314,18 @@ describe("oke dev MCP live wiring", () => {
       mcpPort: 0,
       appPort: 0,
       manifest: LIVE_MANIFEST,
+      ...stubCompose(),
       startApp: async () => ({ stop() {} }),
       regenClient: async () => {},
       write: () => {},
       serveConsole: async (port) => {
-        const { serveConsole } = await import("../console/server/serve.ts");
-        const server = await serveConsole({
-          port,
-          hostname: "127.0.0.1",
-          cwd: dir,
-          secret: SECRET,
-          silentClaim: true,
-          env: "dev",
-          manifest: LIVE_MANIFEST,
-        });
+        const server = await serveTestConsole(port, dir);
         return {
           console: server.console,
           port: server.port,
           stop() {
             consoleStopped = true;
-            server.stop(true);
+            server.stop();
           },
         };
       },
@@ -293,6 +376,7 @@ describe("oke dev docs MCP", () => {
       consolePort: 0,
       mcpPort: 0,
       docsMcpPort: 0,
+      ...stubCompose(),
       startApp: async () => ({ stop() {} }),
       regenClient: async () => {},
       write: () => {},
@@ -366,6 +450,7 @@ describe("oke dev docs MCP", () => {
       consolePort: 0,
       mcpPort: 0,
       docsMcpPort: 0,
+      ...stubCompose(),
       startApp: async () => ({ stop() {} }),
       regenClient: async () => {},
       write: (t) => {
@@ -421,7 +506,7 @@ export const app = oke({ name: "dev-hot", env: "test" }).adopt({ ping });
   );
 }
 
-/** Stub Console + MCP so boot/hot tests isolate the app child. */
+/** Stub Console + MCP + compose so boot/hot tests isolate the app child. */
 function stubSurfaces(): Pick<
   DevOptions,
   | "serveConsole"
@@ -431,6 +516,12 @@ function stubSurfaces(): Pick<
   | "write"
   | "silentClaim"
   | "keepAlive"
+  | "images"
+  | "credentials"
+  | "composeUp"
+  | "composeHealth"
+  | "composeStop"
+  | "noDbPush"
 > {
   return {
     silentClaim: true,
@@ -440,6 +531,7 @@ function stubSurfaces(): Pick<
     serveConsole: async () => ({ stop() {} }),
     serveMcp: async () => ({ stop() {} }),
     serveDocsMcp: async () => ({ stop() {} }),
+    ...stubCompose(),
   };
 }
 
@@ -544,109 +636,133 @@ describe("oke dev hot reload", () => {
   }, 60_000);
 });
 
-describe("oke dev mode resolution", () => {
-  test("non-TTY + unset mode → local, zero ask, zero docker, no save", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "oke-dev-mode-nontty-"));
-    await Bun.write(join(dir, "src/app.ts"), "export {}\n");
-    let askCalls = 0;
-    let composeCalls = 0;
-    const { code, plan } = await runDev({
+describe("oke dev syncAdoptBarrel atomic write", () => {
+  test("default path regenerates generated.ts and leaves no .tmp behind", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-adopt-atomic-"));
+    await mkdir(join(dir, "src/flows/notes"), { recursive: true });
+    await Bun.write(join(dir, "src/flows/notes/index.ts"), "export {};\n");
+    await Bun.write(join(dir, "src/app.ts"), "export {};\n");
+    await Bun.write(join(dir, "src/flows", ADOPT_BARREL_FILE), "// stale stub\n");
+
+    const { code } = await runDev({
       cwd: dir,
       dryRun: true,
       stdinIsTTY: false,
-      ask: async () => {
-        askCalls++;
-        return "docker";
-      },
-      composeUp: async () => {
-        composeCalls++;
-      },
+      images: STUB_IMAGES,
+      credentials: STUB_CREDENTIALS,
       write: () => {},
     });
     expect(code).toBe(0);
-    expect(askCalls).toBe(0);
-    expect(composeCalls).toBe(0);
-    expect(plan?.stackRoles).toBeNull();
-    expect(await readDevMode(dir)).toBeNull();
+
+    const barrelPath = join(dir, "src/flows", ADOPT_BARREL_FILE);
+    const text = await Bun.file(barrelPath).text();
+    expect(text).toContain('export * as notes from "./notes/index.ts";');
+    expect(text).not.toContain("stale stub");
+    expect(await Bun.file(`${barrelPath}.tmp`).exists()).toBe(false);
+    const leftovers = (await readdir(join(dir, "src/flows"))).filter((f) => f.includes(".tmp"));
+    expect(leftovers).toEqual([]);
   });
 
-  test("TTY + unset mode → ask once, save choice", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "oke-dev-mode-tty-"));
-    await Bun.write(join(dir, "src/app.ts"), "export {}\n");
-    let askCalls = 0;
-    const { code } = await runDev({
-      cwd: dir,
-      dryRun: true,
-      stdinIsTTY: true,
-      ask: async () => {
-        askCalls++;
-        return "local";
-      },
-      write: () => {},
-    });
-    expect(code).toBe(0);
-    expect(askCalls).toBe(1);
-    expect(await readDevMode(dir)).toBe("local");
+  test("writeAdoptBarrel uses temp then rename — concurrent readers never see a torn file", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-adopt-race-"));
+    const flowsDir = join(dir, "src/flows");
+    await mkdir(flowsDir, { recursive: true });
+    const target = join(flowsDir, ADOPT_BARREL_FILE);
+
+    // Two complete, same-length payloads so a mid-write truncate would yield
+    // mixed or short content that fails both equality checks.
+    const markerA = "A";
+    const markerB = "B";
+    const body = (marker: string) => `// ${marker}\n` + `${marker.repeat(64)}\n`.repeat(2_000);
+    const payloadA = body(markerA);
+    const payloadB = body(markerB);
+    expect(payloadA.length).toBe(payloadB.length);
+    expect(payloadA).not.toBe(payloadB);
+
+    await writeAdoptBarrel(dir, payloadA);
+    expect(await Bun.file(target).text()).toBe(payloadA);
+
+    const reads: string[] = [];
+    let stop = false;
+    const reader = (async () => {
+      while (!stop) {
+        try {
+          reads.push(await Bun.file(target).text());
+        } catch {
+          // Target briefly missing only if rename races a delete — ignore.
+        }
+        // Yield so writers interleave; Bun.sleep(0) is enough on this loop.
+        await Bun.sleep(0);
+      }
+    })();
+
+    for (let i = 0; i < 80; i++) {
+      await writeAdoptBarrel(dir, i % 2 === 0 ? payloadB : payloadA);
+    }
+    stop = true;
+    await reader;
+
+    expect(reads.length).toBeGreaterThan(10);
+    for (const sample of reads) {
+      // Every observation is a complete prior or complete next payload —
+      // never a truncated prefix, never a mix of A/B markers.
+      const ok = sample === payloadA || sample === payloadB;
+      expect(ok).toBe(true);
+      expect(sample.length).toBe(payloadA.length);
+      expect(sample.includes(markerA) && sample.includes(markerB)).toBe(false);
+    }
+    expect(await Bun.file(`${target}.tmp`).exists()).toBe(false);
+
+    // Same helper the default `oke dev` path uses end-to-end.
+    const { source } = await generateAdoptBarrel({ rootDir: dir });
+    await writeAdoptBarrel(dir, source);
+    expect(await Bun.file(target).text()).toBe(source);
   });
+});
 
-  test("TTY + unset mode → docker choice saves and plans compose on dryRun", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "oke-dev-mode-tty-d-"));
+describe("oke dev Docker-first", () => {
+  test("dryRun always plans compose (no mode ask)", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-always-compose-"));
     await Bun.write(join(dir, "src/app.ts"), "export {}\n");
-    let askCalls = 0;
     let composeCalls = 0;
     const { code, plan } = await runDev({
       cwd: dir,
       dryRun: true,
-      stdinIsTTY: true,
-      images: { "store.sql": "postgres:16-alpine" },
-      credentials: {
-        "store.sql": {
-          user: "oke",
-          password: "test-password-not-in-yaml",
-          database: "oke",
-        },
-      },
-      ask: async () => {
-        askCalls++;
-        return "docker";
-      },
+      stdinIsTTY: false,
+      images: STUB_IMAGES,
+      credentials: STUB_CREDENTIALS,
       composeUp: async () => {
         composeCalls++;
       },
       write: () => {},
     });
     expect(code).toBe(0);
-    expect(askCalls).toBe(1);
     expect(composeCalls).toBe(0);
-    expect(await readDevMode(dir)).toBe("docker");
-    expect(plan?.stackRoles).toEqual(["store.sql"]);
+    expect(plan?.stackRoles).toEqual(["store.sql", "store.kv"]);
   });
 
-  test("session --local never writes .oke/mode", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "oke-dev-mode-local-"));
+  test("role filter -d store.sql plans only that role", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-roles-"));
     await Bun.write(join(dir, "src/app.ts"), "export {}\n");
-    let askCalls = 0;
     const { code, plan } = await runDev({
       cwd: dir,
       dryRun: true,
-      local: true,
-      stdinIsTTY: true,
-      ask: async () => {
-        askCalls++;
-        return "docker";
+      stdinIsTTY: false,
+      docker: ["store.sql"],
+      images: {
+        "store.sql": "postgres:16-alpine",
+        "store.kv": "redis:7-alpine",
       },
+      credentials: STUB_CREDENTIALS,
       write: () => {},
     });
     expect(code).toBe(0);
-    expect(askCalls).toBe(0);
-    expect(plan?.stackRoles).toBeNull();
-    expect(await readDevMode(dir)).toBeNull();
+    expect(plan?.stackRoles).toEqual(["store.sql"]);
   });
 
-  test("session stop calls composeStop after a successful docker up", async () => {
+  test("session stop calls composeStop after a successful compose up", async () => {
     const dir = await mkdtemp(join(tmpdir(), "oke-dev-compose-stop-"));
     await Bun.write(join(dir, "src/app.ts"), "export {}\n");
-    await writeDevMode(dir, "docker");
     let upCalls = 0;
     let stopCalls = 0;
     let stoppedFiles: readonly string[] | undefined;
@@ -659,26 +775,20 @@ describe("oke dev mode resolution", () => {
       const result = await runDev({
         cwd: dir,
         stdinIsTTY: false,
-        images: { "store.sql": "postgres:16-alpine" },
-        credentials: {
-          "store.sql": {
-            user: "oke",
-            password: "test-password-not-in-yaml",
-            database: "oke",
+        ...stubCompose({
+          composeUp: async (files) => {
+            upCalls++;
+            expect(files.length).toBeGreaterThan(0);
           },
-        },
-        composeUp: async (files) => {
-          upCalls++;
-          expect(files.length).toBeGreaterThan(0);
-        },
-        composeHealth: async ({ onUpdate }) => {
-          onUpdate?.("store-sql", "ready");
-          return new Map([["store-sql", "ready"]]);
-        },
-        composeStop: (files) => {
-          stopCalls++;
-          stoppedFiles = files;
-        },
+          composeHealth: async ({ onUpdate }) => {
+            onUpdate?.("store-sql", "ready");
+            return new Map([["store-sql", "ready"]]);
+          },
+          composeStop: (files) => {
+            stopCalls++;
+            stoppedFiles = files;
+          },
+        }),
         startApp: async () => ({ stop() {} }),
         serveConsole: async () => ({ stop() {} }),
         regenClient: async () => {},
@@ -703,10 +813,9 @@ describe("oke dev mode resolution", () => {
     }
   });
 
-  test("saved docker + compose failure exits loudly (no silent downgrade)", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "oke-dev-mode-fail-"));
+  test("compose failure exits loudly (no silent downgrade)", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-compose-fail-"));
     await Bun.write(join(dir, "src/app.ts"), "export {}\n");
-    await writeDevMode(dir, "docker");
     const lines: string[] = [];
     const origErr = console.error;
     console.error = (...args: unknown[]) => {
@@ -716,17 +825,11 @@ describe("oke dev mode resolution", () => {
       const { code } = await runDev({
         cwd: dir,
         stdinIsTTY: false,
-        images: { "store.sql": "postgres:16-alpine" },
-        credentials: {
-          "store.sql": {
-            user: "oke",
-            password: "test-password-not-in-yaml",
-            database: "oke",
+        ...stubCompose({
+          composeUp: async () => {
+            throw new Error("compose boom");
           },
-        },
-        composeUp: async () => {
-          throw new Error("compose boom");
-        },
+        }),
         startApp: async () => ({ stop() {} }),
         serveConsole: async () => ({ stop() {} }),
         regenClient: async () => {},
@@ -734,7 +837,36 @@ describe("oke dev mode resolution", () => {
         keepAlive: false,
       });
       expect(code).toBe(1);
-      expect(lines.some((l) => l.includes("oke mode local"))).toBe(true);
+      expect(lines.some((l) => l.includes("Docker Compose failed"))).toBe(true);
+    } finally {
+      console.error = origErr;
+    }
+  });
+
+  test("missing Docker daemon fails fast with a clear error", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-no-daemon-"));
+    await Bun.write(join(dir, "src/app.ts"), "export {}\n");
+    const lines: string[] = [];
+    const origErr = console.error;
+    console.error = (...args: unknown[]) => {
+      lines.push(args.map(String).join(" "));
+    };
+    try {
+      const { code } = await runDev({
+        cwd: dir,
+        stdinIsTTY: false,
+        images: STUB_IMAGES,
+        credentials: STUB_CREDENTIALS,
+        assertDocker: async () => {
+          throw new Error(
+            "oke dev: Docker daemon unavailable — start Docker Desktop (or the Docker daemon) and retry",
+          );
+        },
+        write: () => {},
+        keepAlive: false,
+      });
+      expect(code).toBe(1);
+      expect(lines.some((l) => l.includes("Docker daemon unavailable"))).toBe(true);
     } finally {
       console.error = origErr;
     }