okengine 0.6.0 → 0.6.1

package/src/docker/dockerfile.integration.test.ts

@@ -1,5 +1,7 @@
 /**
  * Integration: generated Dockerfile builds (and optionally runs).
+ *
+ * Opt-in via `OKE_TEST_DOCKER=1` plus a live Docker daemon. Never an empty pass.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -8,47 +10,50 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { deriveInfrastructure, writeDerivedFiles } from "./index.ts";
 
-async function dockerAvailable(): Promise<boolean> {
+function dockerAvailable(): boolean {
   try {
-    const proc = Bun.spawn(["docker", "info"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const code = await proc.exited;
-    return code === 0;
+    return Bun.spawnSync(["docker", "info"], { stdout: "pipe", stderr: "pipe" }).exitCode === 0;
   } catch {
     return false;
   }
 }
 
-describe("generated Dockerfile integration", () => {
-  test("oke docker output builds and runs", async () => {
-    if (!(await dockerAvailable())) {
-      console.warn("skipping: docker daemon not available");
-      return;
-    }
+const WANT = process.env.OKE_TEST_DOCKER === "1";
+const DOCKER = WANT && dockerAvailable();
+if (!DOCKER) {
+  console.log(
+    WANT
+      ? "skip: generated Dockerfile e2e (docker daemon not available)"
+      : "skip: generated Dockerfile e2e (OKE_TEST_DOCKER≠1)",
+  );
+}
+const live = DOCKER ? test : test.skip;
 
-    const dir = await mkdtemp(join(tmpdir(), "oke-df-build-"));
-    try {
-      // Minimal app that `oke start` can import.
-      await Bun.write(
-        join(dir, "package.json"),
-        JSON.stringify(
-          {
-            name: "oke-docker-fixture",
-            private: true,
-            type: "module",
-            bin: { oke: "./oke.ts" },
-            scripts: { start: "bun ./app.ts" },
-            okengine: { entry: "./app.ts" },
-          },
-          null,
-          2,
-        ),
-      );
-      await Bun.write(
-        join(dir, "oke.ts"),
-        `#!/usr/bin/env bun
+describe("generated Dockerfile integration", () => {
+  live(
+    "oke docker output builds and runs",
+    async () => {
+      const dir = await mkdtemp(join(tmpdir(), "oke-df-build-"));
+      try {
+        // Minimal app that `oke start` can import.
+        await Bun.write(
+          join(dir, "package.json"),
+          JSON.stringify(
+            {
+              name: "oke-docker-fixture",
+              private: true,
+              type: "module",
+              bin: { oke: "./oke.ts" },
+              scripts: { start: "bun ./app.ts" },
+              okengine: { entry: "./app.ts" },
+            },
+            null,
+            2,
+          ),
+        );
+        await Bun.write(
+          join(dir, "oke.ts"),
+          `#!/usr/bin/env bun
 const [cmd] = process.argv.slice(2);
 if (cmd === "start") {
   await import("./app.ts");
@@ -57,10 +62,10 @@ if (cmd === "start") {
   process.exit(1);
 }
 `,
-      );
-      await Bun.write(
-        join(dir, "app.ts"),
-        `const server = Bun.serve({
+        );
+        await Bun.write(
+          join(dir, "app.ts"),
+          `const server = Bun.serve({
   port: Number(process.env.PORT ?? 6530),
   hostname: "0.0.0.0",
   fetch() {
@@ -69,95 +74,97 @@ if (cmd === "start") {
 });
 console.log("listening", server.port);
 `,
-      );
+        );
 
-      // No lockfile — adjust Dockerfile install for the fixture.
-      const derived = deriveInfrastructure({
-        images: { "store.sql": "postgres:18-alpine" },
-        credentials: {
-          "store.sql": {
-            user: "oke",
-            password: "fixture-pass",
-            database: "oke",
+        // No lockfile — adjust Dockerfile install for the fixture.
+        const derived = deriveInfrastructure({
+          images: { "store.sql": "postgres:18-alpine" },
+          credentials: {
+            "store.sql": {
+              user: "oke",
+              password: "fixture-pass",
+              database: "oke",
+            },
           },
-        },
-        app: "fixture",
-        // Flat fixture root (build context `.`).
-        composeDir: ".",
-      });
-      await writeDerivedFiles(derived, dir);
+          app: "fixture",
+          // Flat fixture root (build context `.`).
+          composeDir: ".",
+        });
+        await writeDerivedFiles(derived, dir);
 
-      // Fixture has no bun.lock — rewrite install step.
-      let df = await Bun.file(join(dir, "Dockerfile")).text();
-      df = df.replace(
-        "RUN bun install --frozen-lockfile --production",
-        "RUN bun install --production",
-      );
-      await Bun.write(join(dir, "Dockerfile"), df);
+        // Fixture has no bun.lock — rewrite install step.
+        let df = await Bun.file(join(dir, "Dockerfile")).text();
+        df = df.replace(
+          "RUN bun install --frozen-lockfile --production",
+          "RUN bun install --production",
+        );
+        await Bun.write(join(dir, "Dockerfile"), df);
 
-      const tag = `oke-docker-fixture:${Date.now()}`;
-      const build = Bun.spawn(["docker", "build", "-t", tag, dir], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const [buildOut, buildErr, buildCode] = await Promise.all([
-        new Response(build.stdout).text(),
-        new Response(build.stderr).text(),
-        build.exited,
-      ]);
-      expect(buildCode).toBe(0);
-      if (buildCode !== 0) {
-        console.error(buildOut, buildErr);
-      }
+        const tag = `oke-docker-fixture:${Date.now()}`;
+        const build = Bun.spawn(["docker", "build", "-t", tag, dir], {
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const [buildOut, buildErr, buildCode] = await Promise.all([
+          new Response(build.stdout).text(),
+          new Response(build.stderr).text(),
+          build.exited,
+        ]);
+        expect(buildCode).toBe(0);
+        if (buildCode !== 0) {
+          console.error(buildOut, buildErr);
+        }
 
-      const name = `oke-fixture-run-${Date.now()}`;
-      const run = Bun.spawn(["docker", "run", "-d", "--name", name, "-p", "0:6530", tag], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const [runOut, runErr, runCode] = await Promise.all([
-        new Response(run.stdout).text(),
-        new Response(run.stderr).text(),
-        run.exited,
-      ]);
-      expect(runCode).toBe(0);
-      if (runCode !== 0) console.error(runOut, runErr);
+        const name = `oke-fixture-run-${Date.now()}`;
+        const run = Bun.spawn(["docker", "run", "-d", "--name", name, "-p", "0:6530", tag], {
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const [runOut, runErr, runCode] = await Promise.all([
+          new Response(run.stdout).text(),
+          new Response(run.stderr).text(),
+          run.exited,
+        ]);
+        expect(runCode).toBe(0);
+        if (runCode !== 0) console.error(runOut, runErr);
 
-      // Resolve published port
-      const portProc = Bun.spawn(["docker", "port", name, "6530"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-      const portOut = await new Response(portProc.stdout).text();
-      await portProc.exited;
-      const m = portOut.match(/:(\d+)/);
-      expect(m).toBeTruthy();
-      const hostPort = m![1]!;
+        // Resolve published port
+        const portProc = Bun.spawn(["docker", "port", name, "6530"], {
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        const portOut = await new Response(portProc.stdout).text();
+        await portProc.exited;
+        const m = portOut.match(/:(\d+)/);
+        expect(m).toBeTruthy();
+        const hostPort = m![1]!;
 
-      let body: { ok?: boolean } | null = null;
-      for (let i = 0; i < 20; i++) {
-        try {
-          const res = await fetch(`http://127.0.0.1:${hostPort}/`);
-          if (res.ok) {
-            body = (await res.json()) as { ok?: boolean };
-            break;
+        let body: { ok?: boolean } | null = null;
+        for (let i = 0; i < 20; i++) {
+          try {
+            const res = await fetch(`http://127.0.0.1:${hostPort}/`);
+            if (res.ok) {
+              body = (await res.json()) as { ok?: boolean };
+              break;
+            }
+          } catch {
+            await Bun.sleep(250);
           }
-        } catch {
-          await Bun.sleep(250);
         }
-      }
-      expect(body?.ok).toBe(true);
+        expect(body?.ok).toBe(true);
 
-      await Bun.spawn(["docker", "rm", "-f", name], {
-        stdout: "pipe",
-        stderr: "pipe",
-      }).exited;
-      await Bun.spawn(["docker", "rmi", "-f", tag], {
-        stdout: "pipe",
-        stderr: "pipe",
-      }).exited;
-    } finally {
-      await rm(dir, { recursive: true, force: true }).catch(() => {});
-    }
-  }, 180_000);
+        await Bun.spawn(["docker", "rm", "-f", name], {
+          stdout: "pipe",
+          stderr: "pipe",
+        }).exited;
+        await Bun.spawn(["docker", "rmi", "-f", tag], {
+          stdout: "pipe",
+          stderr: "pipe",
+        }).exited;
+      } finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => {});
+      }
+    },
+    180_000,
+  );
 });

package/src/docker/stack.integration.test.ts

@@ -1,5 +1,7 @@
 /**
  * Integration: generated compose brings up postgres; app URL talks to it.
+ *
+ * Opt-in via `OKE_TEST_DOCKER=1` plus a live Docker daemon. Never an empty pass.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -8,127 +10,141 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { deriveInfrastructure, formatStackEnv, writeDerivedFiles } from "./index.ts";
 
-async function dockerAvailable(): Promise<boolean> {
+function dockerAvailable(): boolean {
   try {
-    const proc = Bun.spawn(["docker", "info"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    return (await proc.exited) === 0;
+    return Bun.spawnSync(["docker", "info"], { stdout: "pipe", stderr: "pipe" }).exitCode === 0;
   } catch {
     return false;
   }
 }
 
-describe("oke dev --docker postgres integration", () => {
-  test("compose brings up postgres and the app talks to it", async () => {
-    if (!(await dockerAvailable())) {
-      console.warn("skipping: docker daemon not available");
-      return;
-    }
-
-    const dir = await mkdtemp(join(tmpdir(), "oke-stack-pg-"));
-    const dockerDir = join(dir, "docker");
-    const project = `oke-pg-${Date.now()}`;
-    try {
-      const derived = deriveInfrastructure({
-        images: { "store.sql": "postgres:18-alpine" },
-        credentials: {
-          "store.sql": {
-            user: "oke",
-            password: "stack-integration-pass",
-            database: "oke",
-          },
-        },
-        app: "stacktest",
-        host: "127.0.0.1",
-        includeApp: false,
-        composeDir: "docker",
-      });
-      await writeDerivedFiles(derived, dockerDir, {
-        writeStackEnv: true,
-      });
+const WANT = process.env.OKE_TEST_DOCKER === "1";
+const DOCKER = WANT && dockerAvailable();
+if (!DOCKER) {
+  console.log(
+    WANT
+      ? "skip: docker postgres stack e2e (docker daemon not available)"
+      : "skip: docker postgres stack e2e (OKE_TEST_DOCKER≠1)",
+  );
+}
+const live = DOCKER ? test : test.skip;
 
-      // Infra-only: network + role compose (no app build).
-      const composeFiles = ["compose.yml", "compose.store.sql.yml"];
-      const up = Bun.spawn(
-        ["docker", "compose", "-p", project, ...composeFiles.flatMap((f) => ["-f", f]), "up", "-d"],
-        {
-          cwd: dockerDir,
-          stdout: "pipe",
-          stderr: "pipe",
-          env: {
-            ...process.env,
-            ...derived.stackEnv,
+describe("oke dev --docker postgres integration", () => {
+  live(
+    "compose brings up postgres and the app talks to it",
+    async () => {
+      const dir = await mkdtemp(join(tmpdir(), "oke-stack-pg-"));
+      const dockerDir = join(dir, "docker");
+      const project = `oke-pg-${Date.now()}`;
+      try {
+        const derived = deriveInfrastructure({
+          images: { "store.sql": "postgres:18-alpine" },
+          credentials: {
+            "store.sql": {
+              user: "oke",
+              password: "stack-integration-pass",
+              database: "oke",
+            },
           },
-        },
-      );
-      const [upOut, upErr, upCode] = await Promise.all([
-        new Response(up.stdout).text(),
-        new Response(up.stderr).text(),
-        up.exited,
-      ]);
-      expect(upCode).toBe(0);
-      if (upCode !== 0) console.error(upOut, upErr);
+          app: "stacktest",
+          host: "127.0.0.1",
+          includeApp: false,
+          composeDir: "docker",
+        });
+        await writeDerivedFiles(derived, dockerDir, {
+          writeStackEnv: true,
+        });
 
-      // Wait for healthy
-      let healthy = false;
-      for (let i = 0; i < 40; i++) {
-        const ps = Bun.spawn(
+        // Infra-only: network + role compose (no app build).
+        const composeFiles = ["compose.yml", "compose.store.sql.yml"];
+        const up = Bun.spawn(
           [
             "docker",
             "compose",
             "-p",
             project,
             ...composeFiles.flatMap((f) => ["-f", f]),
-            "ps",
-            "--format",
-            "json",
+            "up",
+            "-d",
           ],
-          { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
+          {
+            cwd: dockerDir,
+            stdout: "pipe",
+            stderr: "pipe",
+            env: {
+              ...process.env,
+              ...derived.stackEnv,
+            },
+          },
         );
-        const text = await new Response(ps.stdout).text();
-        await ps.exited;
-        if (/healthy/i.test(text)) {
-          healthy = true;
-          break;
+        const [upOut, upErr, upCode] = await Promise.all([
+          new Response(up.stdout).text(),
+          new Response(up.stderr).text(),
+          up.exited,
+        ]);
+        expect(upCode).toBe(0);
+        if (upCode !== 0) console.error(upOut, upErr);
+
+        // Wait for healthy
+        let healthy = false;
+        for (let i = 0; i < 40; i++) {
+          const ps = Bun.spawn(
+            [
+              "docker",
+              "compose",
+              "-p",
+              project,
+              ...composeFiles.flatMap((f) => ["-f", f]),
+              "ps",
+              "--format",
+              "json",
+            ],
+            { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
+          );
+          const text = await new Response(ps.stdout).text();
+          await ps.exited;
+          if (/healthy/i.test(text)) {
+            healthy = true;
+            break;
+          }
+          await Bun.sleep(500);
         }
-        await Bun.sleep(500);
-      }
-      expect(healthy).toBe(true);
+        expect(healthy).toBe(true);
 
-      const url = derived.stackEnv.DATABASE_URL!;
-      // App talks to postgres via recipe URL (Bun.SQL) — kernel never sees env-var names.
-      const sql = new Bun.SQL(url);
-      try {
-        const rows = (await sql`select 1::int as n`) as Array<{ n: number }>;
-        expect(rows[0]?.n).toBe(1);
+        const url = derived.stackEnv.DATABASE_URL!;
+        // App talks to postgres via recipe URL (Bun.SQL) — kernel never sees env-var names.
+        const sql = new Bun.SQL(url);
+        try {
+          const rows = (await sql`select 1::int as n`) as Array<{ n: number }>;
+          expect(rows[0]?.n).toBe(1);
+        } finally {
+          await sql.close();
+        }
+
+        // Prove credentials live in docker/.env.docker, not YAML.
+        const yml = await Bun.file(join(dockerDir, "compose.store.sql.yml")).text();
+        expect(yml).not.toContain("stack-integration-pass");
+        expect(formatStackEnv(derived.stackEnv)).toContain("stack-integration-pass");
+        expect(await Bun.file(join(dockerDir, ".env.docker")).exists()).toBe(true);
       } finally {
-        await sql.close();
+        await Bun.spawn(
+          [
+            "docker",
+            "compose",
+            "-p",
+            project,
+            "-f",
+            "compose.yml",
+            "-f",
+            "compose.store.sql.yml",
+            "down",
+            "-v",
+          ],
+          { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
+        ).exited.catch(() => {});
+        await rm(dir, { recursive: true, force: true }).catch(() => {});
       }
-
-      // Prove credentials live in docker/.env.docker, not YAML.
-      const yml = await Bun.file(join(dockerDir, "compose.store.sql.yml")).text();
-      expect(yml).not.toContain("stack-integration-pass");
-      expect(formatStackEnv(derived.stackEnv)).toContain("stack-integration-pass");
-      expect(await Bun.file(join(dockerDir, ".env.docker")).exists()).toBe(true);
-    } finally {
-      await Bun.spawn(
-        [
-          "docker",
-          "compose",
-          "-p",
-          project,
-          "-f",
-          "compose.yml",
-          "-f",
-          "compose.store.sql.yml",
-          "down",
-          "-v",
-        ],
-        { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
-      ).exited.catch(() => {});
-      await rm(dir, { recursive: true, force: true }).catch(() => {});
-    }
-  }, 120_000);
+    },
+    120_000,
+  );
 });

package/src/drivers/ai-ollama-tools.integration.test.ts

@@ -1,7 +1,8 @@
 /**
  * Live Ollama tool-calling through fx.ask → fx.call (capability + ledger).
  *
- * Same skip-visible convention as ai-ollama.integration.test.ts.
+ * Opt-in via `OKE_TEST_OLLAMA_URL` (reachable Ollama). A local daemon on
+ * :11434 is not enough — set the URL explicitly. Never an empty pass.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -11,7 +12,6 @@ import { createGateRuntime, gate } from "../elements/gate.ts";
 import { createFxContext } from "../kernel/fx.ts";
 import { OLLAMA_DEFAULT_MODEL, openOllama } from "./ai-ollama.ts";
 
-const DEFAULT_LOCAL = "http://127.0.0.1:11434";
 const ENV_URL = process.env.OKE_TEST_OLLAMA_URL?.trim();
 
 async function probeOllama(url: string): Promise<boolean> {
@@ -23,12 +23,14 @@ async function probeOllama(url: string): Promise<boolean> {
   }
 }
 
-const localUp = ENV_URL ? await probeOllama(ENV_URL) : await probeOllama(DEFAULT_LOCAL);
-const canLive = Boolean(ENV_URL) || localUp;
+const reachable = ENV_URL ? await probeOllama(ENV_URL) : false;
+const canLive = Boolean(ENV_URL) && reachable;
 
 if (!canLive) {
   console.log(
-    "skip: live ollama tool-calling e2e (OKE_TEST_OLLAMA_URL not set; no Ollama on :11434)",
+    ENV_URL
+      ? `skip: live ollama tool-calling e2e (unreachable at ${ENV_URL})`
+      : "skip: live ollama tool-calling e2e (OKE_TEST_OLLAMA_URL not set)",
   );
 }
 const live = canLive ? test : test.skip;
@@ -37,7 +39,7 @@ describe("ollama live — tool-calling via fx.call", () => {
   live(
     "gated ask → real tool call → capability ledger portal entry",
     async () => {
-      const url = ENV_URL || DEFAULT_LOCAL;
+      const url = ENV_URL!;
       const model = process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL;
 
       const kv = await memoryKvDriver.open({ name: "ollama-tools-rate" });

package/src/drivers/ai-ollama.integration.test.ts

@@ -3,11 +3,11 @@
  *
  * Opt-in (never auto-pull a multi-GB model in ordinary `bun test`):
  * 1. `OKE_TEST_OLLAMA_URL` — point at any reachable Ollama
- * 2. Ollama already listening on `http://127.0.0.1:11434`
- * 3. `OKE_TEST_OLLAMA_DOCKER=1` — start `ollama/ollama` via the recipe and pull
+ * 2. `OKE_TEST_OLLAMA_DOCKER=1` — start `ollama/ollama` via the recipe and pull
  *    `qwen3.5:9b` (slow first run)
  *
  * Without one of those, the suite skips with a visible reason (never an empty pass).
+ * A local daemon on :11434 is not enough — set `OKE_TEST_OLLAMA_URL` explicitly.
  */
 
 import { afterAll, describe, expect, test } from "bun:test";
@@ -20,7 +20,6 @@ import { bindAi } from "../kernel/boot-bind/ai.ts";
 import { OLLAMA_DEFAULT_MODEL, openOllama } from "./ai-ollama.ts";
 
 const OLLAMA_IMAGE = "ollama/ollama:latest";
-const DEFAULT_LOCAL = "http://127.0.0.1:11434";
 const ENV_URL = process.env.OKE_TEST_OLLAMA_URL?.trim();
 const WANT_DOCKER = process.env.OKE_TEST_OLLAMA_DOCKER === "1";
 
@@ -32,23 +31,12 @@ function dockerAvailable(): boolean {
   }
 }
 
-async function probeOllama(url: string): Promise<boolean> {
-  try {
-    const res = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(1_500) });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
 const DOCKER = dockerAvailable();
-const localUp = ENV_URL ? false : await probeOllama(DEFAULT_LOCAL);
-const canLive = Boolean(ENV_URL) || localUp || (WANT_DOCKER && DOCKER);
+const canLive = Boolean(ENV_URL) || (WANT_DOCKER && DOCKER);
 
 if (!canLive) {
   const reasons: string[] = [];
   if (!ENV_URL) reasons.push("OKE_TEST_OLLAMA_URL not set");
-  if (!localUp) reasons.push("no Ollama on :11434");
   if (!WANT_DOCKER) reasons.push("OKE_TEST_OLLAMA_DOCKER≠1");
   else if (!DOCKER) reasons.push("docker daemon not available");
   console.log(`skip: live ollama e2e (${reasons.join("; ")})`);
@@ -94,10 +82,6 @@ async function resolveLiveUrl(): Promise<{ url: string; model: string }> {
     return { url: ENV_URL, model: process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL };
   }
 
-  if (localUp) {
-    return { url: DEFAULT_LOCAL, model: process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL };
-  }
-
   const dir = await mkdtemp(join(tmpdir(), "oke-ollama-"));
   const dockerDir = join(dir, "docker");
   const project = `oke-ollama-${Date.now()}`;