okengine 0.2.8 → 0.3.4

package/src/cli/dev-db-push.test.ts

@@ -6,7 +6,7 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { runDev, type DevSession } from "./dev.ts";
+import { runDev, type DevSession, type DevWatchFn } from "./dev.ts";
 
 const sessions: DevSession[] = [];
 
@@ -14,6 +14,30 @@ afterEach(() => {
   for (const s of sessions.splice(0)) s.stop();
 });
 
+async function waitFor(predicate: () => boolean, timeoutMs = 3_000): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (!predicate() && Date.now() < deadline) {
+    await Bun.sleep(20);
+  }
+}
+
+function controlledWatcher(): {
+  watchFs: DevWatchFn;
+  change(filename: string): void;
+} {
+  let listener: Parameters<DevWatchFn>[2] | undefined;
+  return {
+    watchFs: (_path, _options, next) => {
+      listener = next;
+      return { close() {} };
+    },
+    change(filename) {
+      if (!listener) throw new Error("watcher not started");
+      listener("change", filename);
+    },
+  };
+}
+
 async function scaffoldProject(): Promise<string> {
   const dir = await mkdtemp(join(tmpdir(), "oke-dev-db-"));
   await mkdir(join(dir, "src"), { recursive: true });
@@ -51,6 +75,7 @@ describe("oke dev db auto-push", () => {
   test("schema change triggers dbPush when auto-push is on", async () => {
     const cwd = await scaffoldProject();
     const pushes: string[] = [];
+    const watcher = controlledWatcher();
     let resolveReady!: () => void;
     const ready = new Promise<void>((r) => {
       resolveReady = r;
@@ -88,6 +113,7 @@ describe("oke dev db auto-push", () => {
       onDbAutoPush: () => {
         resolveReady();
       },
+      watchFs: watcher.watchFs,
       onReady: async (session) => {
         sessions.push(session);
       },
@@ -108,13 +134,15 @@ export const entries = sqliteTable("entries", {
 });
 `,
     );
-    await Bun.sleep(500);
+    watcher.change("schema.ts");
+    await waitFor(() => pushes.length > before);
     expect(pushes.length).toBeGreaterThan(before);
   });
 
   test("--no-db-push / noDbPush never calls dbPush", async () => {
     const cwd = await scaffoldProject();
     const pushes: string[] = [];
+    const watcher = controlledWatcher();
 
     const result = await runDev({
       cwd,
@@ -145,6 +173,7 @@ export const entries = sqliteTable("entries", {
         pushes.push("push");
         return 0;
       },
+      watchFs: watcher.watchFs,
       onReady: async (session) => {
         sessions.push(session);
       },
@@ -157,6 +186,7 @@ export const entries = sqliteTable("entries", {
 export const entries = sqliteTable("entries", { id: text("id").primaryKey(), x: text("x") });
 `,
     );
+    watcher.change("schema.ts");
     await Bun.sleep(500);
     expect(pushes).toHaveLength(0);
   });

package/src/cli/dev-schema-sync.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Mode-switch schema sync pipeline — ensure → emit → push, no data copy.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ConfigEnv } from "../config/index.ts";
+import { sqlDialectForEnv, syncDevSchema } from "./dev-schema-sync.ts";
+
+const dirs: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(dirs.splice(0).map((d) => rm(d, { recursive: true, force: true })));
+});
+
+async function tempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "oke-sync-"));
+  dirs.push(dir);
+  return dir;
+}
+
+describe("sqlDialectForEnv", () => {
+  test("local → sqlite, docker → postgresql", async () => {
+    const config = {
+      drivers: {
+        store: { sql: { local: "sqlite", docker: "postgres", prod: "postgres", test: "memory" } },
+      },
+    } as never;
+    expect(sqlDialectForEnv(config, "local").dialect).toBe("sqlite");
+    expect(sqlDialectForEnv(config, "docker").dialect).toBe("postgresql");
+  });
+
+  test("missing config → sqlite default", () => {
+    expect(sqlDialectForEnv(null, "local").dialect).toBe("sqlite");
+  });
+});
+
+describe("syncDevSchema", () => {
+  test("local: ensures drizzle config, emits, pushes with env", async () => {
+    const dir = await tempDir();
+    const calls: { cwd: string; env: ConfigEnv }[] = [];
+    const result = await syncDevSchema(dir, "local", {
+      write: () => {},
+      pushFn: async (cwd, env) => {
+        calls.push({ cwd, env });
+        return 0;
+      },
+    });
+    expect(result.dialect).toBe("sqlite");
+    expect(result.pushed).toBe(true);
+    expect(calls).toEqual([{ cwd: dir, env: "local" }]);
+    expect(await Bun.file(join(dir, "drizzle.config.ts")).exists()).toBe(true);
+  });
+
+  test("push failure surfaces code without throwing", async () => {
+    const dir = await tempDir();
+    const result = await syncDevSchema(dir, "local", {
+      write: () => {},
+      pushFn: async () => 1,
+    });
+    expect(result.pushed).toBe(false);
+    expect(result.code).toBe(1);
+  });
+});

package/src/cli/dev-schema-sync.ts

@@ -0,0 +1,139 @@
+/**
+ * Shared local↔docker schema sync pipeline for `oke mode` and `oke dev`
+ * one-shot start. Ensures artefacts, emits for the active dialect, then
+ * pushes via drizzle-kit. Data planes stay isolated — no row copying.
+ */
+
+import { resolve } from "node:path";
+import { resolveDriverId, type ConfigEnv, type OkeConfig } from "../config/index.ts";
+import {
+  DEFAULT_DOCKER_DIR,
+  deriveInfrastructure,
+  loadExistingStackControls,
+  loadExistingStackCredentials,
+  stackAppSlug,
+  stackInstanceId,
+  writeDerivedFiles,
+} from "../docker/index.ts";
+import { drizzleDialectFromSqlDriver } from "../drivers/drizzle-dialect.ts";
+import { ensureDrizzleConfig } from "./ensure-drizzle-config.ts";
+import { runDb } from "./db.ts";
+import { loadOkeConfig, resolveImages } from "./load-config.ts";
+
+/** Options for {@link syncDevSchema}. */
+export interface DevSchemaSyncOptions {
+  /** Write output (default: stdout). */
+  readonly write?: (text: string) => void;
+  /** Skip emitting `schema.generated.ts` (tests). */
+  readonly skipEmit?: boolean;
+  /** Injectable push (tests). Default: `runDb("push", ...)`. */
+  readonly pushFn?: (cwd: string, env: ConfigEnv) => Promise<number>;
+  /** Derive docker infra without running compose (tests). */
+  readonly dryRun?: boolean;
+}
+
+/** Outcome of {@link syncDevSchema}. */
+export interface DevSchemaSyncResult {
+  readonly env: ConfigEnv;
+  readonly dialect: "sqlite" | "postgresql";
+  readonly pushed: boolean;
+  readonly code: number;
+}
+
+/**
+ * Resolve the SQL driver id + drizzle dialect for an env from config.
+ *
+ * @param config - Loaded oke config
+ * @param env - Active env
+ */
+export function sqlDialectForEnv(
+  config: OkeConfig | null | undefined,
+  env: ConfigEnv,
+): { readonly driverId: string; readonly dialect: "sqlite" | "postgresql" } {
+  const driverId = resolveDriverId(config?.drivers?.store?.sql, env) ?? "sqlite";
+  if (driverId !== "sqlite" && driverId !== "postgres") {
+    throw new Error(
+      `store.sql driver "${driverId}" is not supported by drizzle-kit (sqlite | postgres)`,
+    );
+  }
+  return { driverId, dialect: drizzleDialectFromSqlDriver(driverId) };
+}
+
+/**
+ * Ensure docker compose artefacts + credentials exist. Fails loudly with a
+ * clear hint when images are not configured (no silent retry loop).
+ *
+ * @param cwd - Project root
+ * @param config - Loaded oke config
+ * @param write - Output
+ */
+async function ensureDockerStack(
+  cwd: string,
+  config: OkeConfig,
+  write: (text: string) => void,
+): Promise<void> {
+  const images = resolveImages(config);
+  if (Object.keys(images).length === 0) {
+    throw new Error(
+      "docker mode: no images configured — set `images` in oke.config.ts (or prod drivers postgres/redis for defaults)",
+    );
+  }
+  const roles = Object.keys(images);
+  const instanceId = stackInstanceId(cwd);
+  const appSlug = stackAppSlug(cwd);
+  const credentials = await loadExistingStackCredentials(cwd, roles);
+  const controls = await loadExistingStackControls(cwd);
+  const derived = deriveInfrastructure({
+    images,
+    app: appSlug,
+    prod: false,
+    includeApp: false,
+    composeDir: DEFAULT_DOCKER_DIR,
+    instanceId,
+    ...(credentials ? { credentials } : {}),
+    ...(controls ? { controls } : {}),
+    host: "127.0.0.1",
+  });
+  await writeDerivedFiles(derived, resolve(cwd, DEFAULT_DOCKER_DIR), { writeStackEnv: true });
+  write(
+    "oke: docker compose env ready under docker/.env.docker (start containers with `oke dev -d` or docker compose up)\n",
+  );
+}
+
+/**
+ * Ensure artefacts, emit for the active dialect, and push schema for an env.
+ * Returns a one-line summary outcome. Docker mode also ensures compose env
+ * exists (writes `docker/.env.docker`) before pushing to the live DB.
+ *
+ * @param cwd - Project root
+ * @param env - Target env (`local` | `docker`)
+ * @param options - Injectables
+ */
+export async function syncDevSchema(
+  cwd: string,
+  env: ConfigEnv,
+  options: DevSchemaSyncOptions = {},
+): Promise<DevSchemaSyncResult> {
+  const write = options.write ?? ((t) => process.stdout.write(t));
+  const loaded = await loadOkeConfig(cwd).catch(() => null);
+  const config = loaded?.config;
+
+  await ensureDrizzleConfig(cwd);
+
+  const { dialect } = sqlDialectForEnv(config, env);
+
+  if (env === "docker") {
+    if (!config) {
+      throw new Error("docker mode: oke.config.ts not found");
+    }
+    await ensureDockerStack(cwd, config, write);
+  }
+
+  const push =
+    options.pushFn ??
+    (async (projectCwd, envArg) =>
+      runDb("push", { cwd: projectCwd, env: envArg, write, skipEmit: options.skipEmit }));
+
+  const code = await push(cwd, env);
+  return { env, dialect, pushed: code === 0, code };
+}

package/src/cli/dev.test.ts

@@ -272,6 +272,121 @@ describe("oke dev MCP live wiring", () => {
   });
 });
 
+describe("oke dev docs MCP", () => {
+  let session: DevSession | undefined;
+
+  afterEach(() => {
+    session?.stop();
+    session = undefined;
+  });
+
+  test("boots the real docs MCP on :6536 next to the runtime MCP — no auth, search works", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-docs-mcp-"));
+    await Bun.write(join(dir, "src/app.ts"), "export {}\n");
+
+    const result = await runDev({
+      stdinIsTTY: false,
+      cwd: dir,
+      silentClaim: true,
+      keepAlive: false,
+      appPort: 0,
+      consolePort: 0,
+      mcpPort: 0,
+      docsMcpPort: 0,
+      startApp: async () => ({ stop() {} }),
+      regenClient: async () => {},
+      write: () => {},
+      // Docs MCP must boot even when Console state is absent (headless).
+      serveConsole: async () => ({ stop() {} }),
+      serveMcp: async () => ({ stop() {} }),
+    });
+
+    expect(result.code).toBe(0);
+    session = result.session;
+    expect(session).toBeDefined();
+    if (!session) return;
+
+    expect(session.docsMcpUrl).toBeTruthy();
+    const docsBase = session.docsMcpUrl!.origin;
+    const host = `127.0.0.1:${session.docsMcpPort}`;
+
+    const health = await fetch(`${docsBase}/health`, { headers: { host } });
+    expect(health.status).toBe(200);
+    expect(await health.json()).toEqual({ ok: true, surface: "docs-mcp" });
+
+    // No Authorization header — docs MCP serves public documentation.
+    const listRes = await fetch(`${docsBase}/mcp`, {
+      method: "POST",
+      headers: { host, "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} }),
+    });
+    expect(listRes.status).toBe(200);
+    const listBody = (await listRes.json()) as {
+      result: { tools: { name: string }[] };
+    };
+    const toolNames = listBody.result.tools.map((t) => t.name);
+    expect(toolNames).toContain("oke.docs.search");
+    expect(toolNames).toContain("oke.docs.get");
+
+    const searchRes = await fetch(`${docsBase}/mcp`, {
+      method: "POST",
+      headers: { host, "content-type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: { name: "oke.docs.search", arguments: { query: "vault" } },
+      }),
+    });
+    expect(searchRes.status).toBe(200);
+    const searchBody = (await searchRes.json()) as {
+      result: {
+        structuredContent: { kind: string; content: { hits: { slug: string }[] } };
+      };
+    };
+    expect(searchBody.result.structuredContent.kind).toBe(MCP_DATA_KIND);
+    expect(searchBody.result.structuredContent.content.hits.length).toBeGreaterThan(0);
+
+    session.stop();
+    session = undefined;
+    await expect(fetch(`${docsBase}/health`, { headers: { host } })).rejects.toThrow();
+  }, 60_000);
+
+  test("skips docs MCP without killing oke dev when the surface fails to boot", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "oke-dev-docs-skip-"));
+    await Bun.write(join(dir, "src/app.ts"), "export {}\n");
+
+    const writes: string[] = [];
+    const result = await runDev({
+      stdinIsTTY: false,
+      cwd: dir,
+      silentClaim: true,
+      keepAlive: false,
+      appPort: 0,
+      consolePort: 0,
+      mcpPort: 0,
+      docsMcpPort: 0,
+      startApp: async () => ({ stop() {} }),
+      regenClient: async () => {},
+      write: (t) => {
+        writes.push(t);
+      },
+      serveConsole: async () => ({ stop() {} }),
+      serveMcp: async () => ({ stop() {} }),
+      serveDocsMcp: async () => {
+        throw new Error("docs content missing");
+      },
+    });
+
+    expect(result.code).toBe(0);
+    session = result.session;
+    expect(session).toBeDefined();
+    if (!session) return;
+    expect(session.docsMcpUrl).toBeNull();
+    expect(writes.join("")).toContain("Docs MCP skipped");
+  }, 60_000);
+});
+
 /**
  * Write a minimal HTTP flow app whose `do` returns `{ version }`.
  *
@@ -311,7 +426,13 @@ export const app = oke({ name: "dev-hot", env: "test" }).adopt({ ping });
 /** Stub Console + MCP so boot/hot tests isolate the app child. */
 function stubSurfaces(): Pick<
   DevOptions,
-  "serveConsole" | "serveMcp" | "regenClient" | "write" | "silentClaim" | "keepAlive"
+  | "serveConsole"
+  | "serveMcp"
+  | "serveDocsMcp"
+  | "regenClient"
+  | "write"
+  | "silentClaim"
+  | "keepAlive"
 > {
   return {
     silentClaim: true,
@@ -320,6 +441,7 @@ function stubSurfaces(): Pick<
     write: () => {},
     serveConsole: async () => ({ stop() {} }),
     serveMcp: async () => ({ stop() {} }),
+    serveDocsMcp: async () => ({ stop() {} }),
   };
 }