okengine 0.10.1 → 0.10.3

package/src/cli/ai-setup/apply.ts

@@ -5,6 +5,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { OLLAMA_IMAGE } from "../../docker/recipes/index.ts";
+import { DEFAULT_DOCKER_DIR } from "../../docker/types.ts";
 
 /** Choices applied to the project. */
 export type AiSetupApplyInput = {
@@ -91,6 +92,18 @@ export function applyAiSetup(
   }
   writeFileSync(envPath, env.endsWith("\n") ? env : `${env}\n`, "utf8");
 
+  // `docker/.env.docker` is regenerated from `.env.local` only on its first
+  // boot (existing values there are treated as durable, possibly hand-edited
+  // pins — see stack-id.ts). Once it exists, a later `oke ai setup` run must
+  // update it directly, or the docker profile keeps the old model forever.
+  if (input.chatModel) {
+    const dockerEnvPath = join(cwd, DEFAULT_DOCKER_DIR, ".env.docker");
+    if (existsSync(dockerEnvPath)) {
+      const dockerEnv = readFileSync(dockerEnvPath, "utf8");
+      writeFileSync(dockerEnvPath, upsertEnv(dockerEnv, "OKE_AI_MODEL", input.chatModel), "utf8");
+    }
+  }
+
   const aiTsPath = join(cwd, "src", "core", "ai.ts");
   mkdirSync(dirname(aiTsPath), { recursive: true });
   writeFileSync(aiTsPath, renderAiTs(input), "utf8");

package/src/cli/build.test.ts

@@ -0,0 +1,67 @@
+/**
+ * `oke build` regenerates `src/flows/generated.ts` before bundling — real
+ * before/after proof, not an assumption about the wiring.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runBuild } from "./build.ts";
+
+async function makeUnit(root: string, name: string): Promise<void> {
+  const dir = join(root, "src/flows", name);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "index.ts"), "export const nothing = 1;\n");
+}
+
+describe("oke build — .adopt() barrel regeneration", () => {
+  test("real before/after: no generated.ts before build, real barrel content after", async () => {
+    const root = await mkdtemp(join(tmpdir(), "oke-build-adopt-"));
+    try {
+      await makeUnit(root, "main");
+      await makeUnit(root, "notes");
+
+      const generatedPath = join(root, "src/flows/generated.ts");
+      await expect(readFile(generatedPath, "utf8")).rejects.toThrow();
+
+      const code = await runBuild({
+        rootDir: root,
+        bundle: async () => ({ success: true, logs: "" }),
+      });
+      expect(code).toBe(0);
+
+      const after = await readFile(generatedPath, "utf8");
+      expect(after).toContain('export * as main from "./main/index.ts";');
+      expect(after).toContain('export * as notes from "./notes/index.ts";');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("regeneration runs before bundling, using the injected syncAdoptBarrel", async () => {
+    const calls: string[] = [];
+    const code = await runBuild({
+      rootDir: "/fake/root",
+      syncAdoptBarrel: async (rootDir) => {
+        calls.push(`sync:${rootDir}`);
+        return ["main", "notes"];
+      },
+      bundle: async () => {
+        calls.push("bundle");
+        return { success: true, logs: "" };
+      },
+    });
+    expect(code).toBe(0);
+    expect(calls).toEqual(["sync:/fake/root", "bundle"]);
+  });
+
+  test("bundle failure still returns non-zero after a successful sync", async () => {
+    const code = await runBuild({
+      rootDir: "/fake/root",
+      syncAdoptBarrel: async () => [],
+      bundle: async () => ({ success: false, logs: "boom" }),
+    });
+    expect(code).toBe(1);
+  });
+});

package/src/cli/build.ts

@@ -8,12 +8,39 @@ export interface BuildOptions {
   readonly entry?: string;
   readonly outdir?: string;
   readonly write?: (text: string) => void;
+  /** Project root for the `.adopt()` barrel sync (default `process.cwd()`). */
+  readonly rootDir?: string;
   /** Inject bun.build (tests). */
   readonly bundle?: (opts: {
     entry: string;
     outdir: string;
     target: "bun" | "node" | "browser";
   }) => Promise<{ success: boolean; logs: string }>;
+  /**
+   * Inject `.adopt()` barrel regeneration (tests). Default: real
+   * `generateAdoptBarrel` + atomic write to `<rootDir>/src/flows/generated.ts`
+   * (`generated.ts.tmp` → rename). Returns the unit names written, for the
+   * status line.
+   */
+  readonly syncAdoptBarrel?: (rootDir: string) => Promise<readonly string[]>;
+}
+
+/**
+ * Regenerate `src/flows/generated.ts` from every `src/flows/<unit>/index.ts`
+ * unit folder — pre-step for `oke build` (mirrors `oke db`'s `schema.generated.ts`
+ * pre-step). A real file on disk, not a virtual module: identical resolution
+ * under `oke dev`'s runtime `import()` and `oke build`'s `Bun.build()`
+ * (investigated — a virtual-module Bun plugin does not resolve consistently
+ * across those two paths). Written atomically so a concurrent reader never
+ * sees a torn file.
+ *
+ * @param rootDir - Project root
+ */
+async function defaultSyncAdoptBarrel(rootDir: string): Promise<readonly string[]> {
+  const { generateAdoptBarrel, writeAdoptBarrel } = await import("../compiler/generate-adopt.ts");
+  const { source, units } = await generateAdoptBarrel({ rootDir });
+  await writeAdoptBarrel(rootDir, source);
+  return units;
 }
 
 /**
@@ -26,6 +53,7 @@ export async function runBuild(options: BuildOptions = {}): Promise<number> {
   const target = options.target ?? "bun";
   const entry = options.entry ?? "src/app.ts";
   const outdir = options.outdir ?? "dist";
+  const rootDir = options.rootDir ?? process.cwd();
   const bunTarget = target === "edge" ? "browser" : target === "node" ? "node" : "bun";
 
   const bundle =
@@ -43,8 +71,13 @@ export async function runBuild(options: BuildOptions = {}): Promise<number> {
         logs: result.logs.map((l) => String(l)).join("\n"),
       };
     });
+  const syncAdoptBarrel = options.syncAdoptBarrel ?? defaultSyncAdoptBarrel;
 
   try {
+    const units = await syncAdoptBarrel(rootDir);
+    write(
+      `oke build: .adopt() barrel → src/flows/generated.ts (${units.length} unit${units.length === 1 ? "" : "s"})\n`,
+    );
     const result = await bundle({ entry, outdir, target: bunTarget });
     if (!result.success) {
       console.error(result.logs || "oke build: failed");

package/src/cli/db-seed.ts

@@ -233,7 +233,7 @@ export async function bootSeedFx(
   if (!app) {
     throw new Error(`oke db seed: no oke() app export in ${entryAbs}`);
   }
-  await app.boot({ env, startScheduler: false, config: config ?? undefined });
+  await app.boot({ env, startScheduler: false, config: config ?? undefined, rootDir: cwd });
   const storeRuntime = app.elements?.store ?? app.bootResult?.store;
   if (!storeRuntime) {
     throw new Error(

package/src/cli/dev-controls.test.ts

@@ -1,65 +1,42 @@
 import { describe, expect, test } from "bun:test";
 import {
-  controlServicesFromStack,
   createDevControlDispatcher,
   formatDevControlsHelp,
   formatDevControlsHint,
-  formatDevControlsServiceList,
   parseDevControlKey,
 } from "./dev-controls.ts";
 
+const CTRL_C = String.fromCharCode(3);
+
 describe("dev-controls", () => {
   test("parseDevControlKey maps raw keys", () => {
     expect(parseDevControlKey("q")).toBe("q");
-    expect(parseDevControlKey("\u0003")).toBe("q");
     expect(parseDevControlKey("?")).toBe("?");
     expect(parseDevControlKey("h")).toBe("?");
-    expect(parseDevControlKey("c")).toBe("c");
-    expect(parseDevControlKey("l")).toBe("l");
+    expect(parseDevControlKey("r")).toBe("r");
     expect(parseDevControlKey("u")).toBe("u");
     expect(parseDevControlKey("x")).toBe("x");
-    expect(parseDevControlKey("r")).toBe("r");
-    expect(parseDevControlKey("3")).toBe("3");
-    expect(parseDevControlKey("\u001b")).toBe("esc");
+    expect(parseDevControlKey("c")).toBeNull();
+    expect(parseDevControlKey("l")).toBeNull();
+    expect(parseDevControlKey("3")).toBeNull();
+    expect(parseDevControlKey("")).toBeNull();
     expect(parseDevControlKey("z")).toBeNull();
   });
 
+  test("parseDevControlKey maps Ctrl+C to quit", () => {
+    expect(parseDevControlKey(CTRL_C)).toBe("q");
+  });
+
   test("format hint and help are scannable", () => {
     expect(formatDevControlsHint(false)).toContain("keys");
     expect(formatDevControlsHint(false)).toContain("refresh");
     expect(formatDevControlsHint(false)).toContain("quit");
-    expect(formatDevControlsHelp(false)).toContain("select service");
+    expect(formatDevControlsHint(false)).not.toContain("services");
     expect(formatDevControlsHelp(false)).toContain("refresh");
-    expect(formatDevControlsHelp(false)).not.toMatch(/\u001b\[/);
+    expect(formatDevControlsHelp(false)).not.toContain("select service");
   });
 
-  test("controlServicesFromStack dedupes by serviceName", () => {
-    const list = controlServicesFromStack([
-      { label: "ai", serviceName: "ai" },
-      { label: "mail", serviceName: "channel-email" },
-      { label: "mail-ui", serviceName: "channel-email" },
-      { label: "postgres", serviceName: "store-sql" },
-    ]);
-    expect(list.map((s) => s.serviceName)).toEqual(["ai", "channel-email", "store-sql"]);
-  });
-
-  test("formatDevControlsServiceList numbers rows", () => {
-    const out = formatDevControlsServiceList(
-      [
-        { label: "ai", serviceName: "ai" },
-        { label: "postgres", serviceName: "store-sql" },
-      ],
-      (name) => (name === "ai" ? "error" : "ready"),
-      false,
-      1,
-    );
-    expect(out).toContain("1");
-    expect(out).toContain("ai");
-    expect(out).toContain("postgres");
-    expect(out).toContain(">");
-  });
-
-  test("dispatcher select → stop → up stack → quit", async () => {
+  test("dispatcher up -> stop -> refresh -> help -> quit", async () => {
     const calls: string[] = [];
     let quit = false;
     let settled = 0;
@@ -79,29 +56,47 @@ describe("dev-controls", () => {
       onComposeSettled: () => {
         settled += 1;
       },
-      services: () => [
-        { label: "ai", serviceName: "ai" },
-        { label: "postgres", serviceName: "store-sql" },
-      ],
-      composeAction: async (action, names) => {
-        calls.push(`${action}:${names.join(",") || "*"}`);
+      composeAction: async (action) => {
+        calls.push(action);
       },
     });
-    d.handleKey("l");
+    d.handleKey("u");
     await Bun.sleep(10);
-    d.handleKey("1");
     d.handleKey("x");
     await Bun.sleep(10);
-    d.handleKey("u");
+    d.handleKey("r");
     await Bun.sleep(10);
-    d.handleKey("c");
+    d.handleKey("?");
     await Bun.sleep(10);
     d.handleKey("q");
-    expect(calls).toEqual(["stop:ai", "up:*"]);
+    expect(calls).toEqual(["up", "stop"]);
     expect(settled).toBe(2);
     expect(refreshed).toBe(1);
     expect(panels).toBe(1);
     expect(quit).toBe(true);
     d.stop();
   });
+
+  test("busy compose action ignores a concurrent key press", async () => {
+    let running = 0;
+    let maxConcurrent = 0;
+    const calls: string[] = [];
+    const d = createDevControlDispatcher({
+      write: () => {},
+      onQuit: () => {},
+      composeAction: async (action) => {
+        running += 1;
+        maxConcurrent = Math.max(maxConcurrent, running);
+        await Bun.sleep(20);
+        calls.push(action);
+        running -= 1;
+      },
+    });
+    d.handleKey("u");
+    d.handleKey("x");
+    await Bun.sleep(40);
+    expect(calls).toEqual(["up"]);
+    expect(maxConcurrent).toBe(1);
+    d.stop();
+  });
 });

package/src/cli/dev-controls.ts

@@ -1,31 +1,17 @@
 /**
  * Keyboard controls for a live `oke dev` session (TTY raw mode).
  *
- * Keys: `?` help · `q` quit · `c` refresh · `l` list · `u` up all ·
- * `x` stop all · `1`–`9` select service then `u`/`x`/`r`.
+ * Keys: `?` help · `q` quit · `r` refresh · `u` up all · `x` stop all.
  *
- * Compose health / model phase update the status board above Logs — not
- * the log stream. `c` clears the TTY and reprints the latest board.
+ * Compose health / model phase update the status board above Logs — it
+ * already lists every service with a live ● status, so refresh alone is
+ * enough to see the stack; there is no separate services panel.
  */
 
-import {
-  formatStatusDot,
-  formatStatusLine,
-  termColorEnabled,
-  termStyle,
-  type DevStatus,
-} from "../term.ts";
+import { formatStatusLine, termColorEnabled, termStyle } from "../term.ts";
 
-/** One Docker service row addressable by a digit key. */
-export type DevControlService = {
-  /** Human label (`ai`, `postgres`). */
-  readonly label: string;
-  /** Compose service name (`ai`, `store-sql`). */
-  readonly serviceName: string;
-};
-
-/** Compose action against zero or more service names. */
-export type DevComposeControlAction = "up" | "stop" | "restart";
+/** Compose action against the whole stack. */
+export type DevComposeControlAction = "up" | "stop";
 
 /** Options for {@link startDevControls}. */
 export type StartDevControlsOptions = {
@@ -37,30 +23,22 @@ export type StartDevControlsOptions = {
    */
   readonly onRefresh?: () => void | Promise<void>;
   /**
-   * Show help / services in a clean pane (typically refresh chrome first so
-   * the panel is not interleaved with request logs).
+   * Show help in a clean pane (refreshes chrome first so the panel is not
+   * interleaved with request logs).
    *
    * @param body - Formatted panel text
    */
   readonly onShowPanel?: (body: string) => void | Promise<void>;
   /**
-   * After a compose up/stop/restart — sync health into the board (no log lines).
+   * After a compose up/stop — sync health into the board (no log lines).
    */
   readonly onComposeSettled?: () => void | Promise<void>;
-  /** Live service catalogue (unique compose services). */
-  readonly services: () => readonly DevControlService[];
   /**
-   * Run a compose control action.
+   * Run a compose control action against the whole stack.
    *
-   * @param action - up / stop / restart
-   * @param serviceNames - Empty → whole stack
+   * @param action - up / stop
    */
-  readonly composeAction: (
-    action: DevComposeControlAction,
-    serviceNames: readonly string[],
-  ) => Promise<void>;
-  /** Optional live ● status for list view. */
-  readonly statusOf?: (serviceName: string) => DevStatus | undefined;
+  readonly composeAction: (action: DevComposeControlAction) => Promise<void>;
   readonly stdin?: NodeJS.ReadStream;
   readonly isTTY?: boolean;
   readonly color?: boolean;
@@ -81,9 +59,8 @@ export function formatDevControlsHint(color: boolean = termColorEnabled()): stri
   return (
     `${s.dim}│${s.reset}  ${s.dim}keys${s.reset}  ` +
     `${s.cyan}?${s.reset} help · ` +
-    `${s.cyan}c${s.reset} refresh · ` +
+    `${s.cyan}r${s.reset} refresh · ` +
     `${s.cyan}q${s.reset} quit · ` +
-    `${s.cyan}l${s.reset} services · ` +
     `${s.cyan}u${s.reset} up · ` +
     `${s.cyan}x${s.reset} stop` +
     `\n`
@@ -104,63 +81,15 @@ export function formatDevControlsHelp(color: boolean = termColorEnabled()): stri
     "",
     `${s.green}◇${s.reset}  ${s.bold}Keys${s.reset}`,
     k("?", "help"),
-    k("c", "refresh — clear logs, show latest ●"),
+    k("r", "refresh — clear logs, show latest ●"),
     k("q", "quit oke dev"),
-    k("l", "list docker services"),
     k("u", "compose up -d (all)"),
     k("x", "compose stop (all)"),
-    k("1-9", "select service"),
-    k("… u", "start selected"),
-    k("… x", "stop selected"),
-    k("… r", "restart selected"),
-    k("esc", "clear selection"),
     bar,
     "",
   ].join("\n");
 }
 
-/**
- * Format a numbered service list for `l`.
- *
- * @param services - Catalogue
- * @param statusOf - Optional ● lookup
- * @param color - Color on/off
- * @param selected - Highlighted 1-based index
- */
-export function formatDevControlsServiceList(
-  services: readonly DevControlService[],
-  statusOf?: (serviceName: string) => DevStatus | undefined,
-  color: boolean = termColorEnabled(),
-  selected?: number,
-): string {
-  const s = termStyle(color);
-  const bar = `${s.dim}│${s.reset}`;
-  if (services.length === 0) {
-    return `${bar}  ${s.dim}no docker services${s.reset}\n`;
-  }
-  const lines = [
-    "",
-    `${s.green}◇${s.reset}  ${s.bold}Services${s.reset}  ${s.dim}1-9 then u/x/r${s.reset}`,
-  ];
-  const max = Math.min(9, services.length);
-  for (let i = 0; i < max; i++) {
-    const svc = services[i]!;
-    const st = statusOf?.(svc.serviceName) ?? "pending";
-    const dot = formatStatusDot(st, color);
-    const num = `${i + 1}`;
-    const mark = selected === i + 1 ? `${s.cyan}>${s.reset}` : " ";
-    lines.push(
-      `${bar}  ${mark}${s.cyan}${num}${s.reset}  ${dot}  ${svc.label.padEnd(12)}  ${s.dim}${svc.serviceName}${s.reset}`,
-    );
-  }
-  if (services.length > 9) {
-    lines.push(`${bar}  ${s.dim}… ${services.length - 9} more (first 9 only)${s.reset}`);
-  }
-  lines.push(bar);
-  lines.push("");
-  return `${lines.join("\n")}\n`;
-}
-
 /**
  * Parse one raw stdin chunk into a control key (tests / non-TTY inject).
  *
@@ -169,16 +98,12 @@ export function formatDevControlsServiceList(
 export function parseDevControlKey(chunk: string): string | null {
   if (chunk.length === 0) return null;
   if (chunk === "\u0003") return "q"; // Ctrl+C
-  if (chunk === "\u001b") return "esc";
   const ch = chunk[0]!;
   if (ch === "?" || ch === "h" || ch === "H") return "?";
-  if (ch === "c" || ch === "C") return "c";
   if (ch === "q" || ch === "Q") return "q";
-  if (ch === "l" || ch === "L") return "l";
+  if (ch === "r" || ch === "R") return "r";
   if (ch === "u" || ch === "U") return "u";
   if (ch === "x" || ch === "X") return "x";
-  if (ch === "r" || ch === "R") return "r";
-  if (ch >= "1" && ch <= "9") return ch;
   return null;
 }
 
@@ -191,23 +116,18 @@ export type DevControlDispatcher = {
 /**
  * Pure key dispatcher (no stdin) — used by tests and the TTY listener.
  *
- * @param opts - Quit / compose / services
+ * @param opts - Quit / compose actions
  */
 export function createDevControlDispatcher(opts: StartDevControlsOptions): DevControlDispatcher {
   const color = opts.color ?? termColorEnabled();
-  let selected: number | null = null;
   let busy = false;
   let stopped = false;
 
-  const runAction = async (
-    action: DevComposeControlAction,
-    serviceNames: readonly string[],
-    _label: string,
-  ): Promise<void> => {
+  const runAction = async (action: DevComposeControlAction): Promise<void> => {
     if (busy) return;
     busy = true;
     try {
-      await opts.composeAction(action, serviceNames);
+      await opts.composeAction(action);
       await opts.onComposeSettled?.();
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -224,7 +144,7 @@ export function createDevControlDispatcher(opts: StartDevControlsOptions): DevCo
         opts.onQuit();
         return;
       }
-      if (key === "c") {
+      if (key === "r") {
         void Promise.resolve(opts.onRefresh?.()).catch((err: unknown) => {
           const msg = err instanceof Error ? err.message : String(err);
           opts.write(formatStatusLine(`refresh failed — ${msg}`, color, "error"));
@@ -236,58 +156,8 @@ export function createDevControlDispatcher(opts: StartDevControlsOptions): DevCo
         void Promise.resolve(opts.onShowPanel?.(body) ?? opts.write(body));
         return;
       }
-      if (key === "esc") {
-        selected = null;
-        return;
-      }
-      if (key === "l") {
-        const body = formatDevControlsServiceList(
-          opts.services(),
-          opts.statusOf,
-          color,
-          selected ?? undefined,
-        );
-        void Promise.resolve(opts.onShowPanel?.(body) ?? opts.write(body));
-        return;
-      }
-      if (key >= "1" && key <= "9") {
-        const n = Number(key);
-        const list = opts.services();
-        if (n < 1 || n > list.length || n > 9) {
-          opts.write(formatStatusLine(`no service ${n} — press l to list`, color, "pending"));
-          return;
-        }
-        selected = n;
-        const svc = list[n - 1]!;
-        opts.write(
-          formatStatusLine(
-            `selected ${n} ${svc.label} — u start · x stop · r restart · esc`,
-            color,
-            opts.statusOf?.(svc.serviceName) ?? "pending",
-          ),
-        );
-        return;
-      }
-      if (key === "u" || key === "x" || key === "r") {
-        const action: DevComposeControlAction =
-          key === "u" ? "up" : key === "x" ? "stop" : "restart";
-        if (selected !== null) {
-          const list = opts.services();
-          const svc = list[selected - 1];
-          if (!svc) {
-            selected = null;
-            opts.write(formatStatusLine("selection expired — press l", color, "pending"));
-            return;
-          }
-          selected = null;
-          void runAction(action, [svc.serviceName], svc.label);
-          return;
-        }
-        if (key === "r") {
-          opts.write(formatStatusLine("select a service first (l then 1-9)", color, "pending"));
-          return;
-        }
-        void runAction(action, [], "stack");
+      if (key === "u" || key === "x") {
+        void runAction(key === "u" ? "up" : "stop");
       }
     },
     stop() {
@@ -299,7 +169,7 @@ export function createDevControlDispatcher(opts: StartDevControlsOptions): DevCo
 /**
  * Start raw-mode keyboard controls. No-op when stdin is not a TTY.
  *
- * @param opts - Quit / compose / services
+ * @param opts - Quit / compose actions
  */
 export function startDevControls(opts: StartDevControlsOptions): DevControlsHandle {
   const stdin = opts.stdin ?? process.stdin;
@@ -333,22 +203,3 @@ export function startDevControls(opts: StartDevControlsOptions): DevControlsHand
     },
   };
 }
-
-/**
- * Dedupe stack summary rows into control services (first label wins).
- *
- * @param rows - Stack summary services with compose names
- */
-export function controlServicesFromStack(
-  rows: readonly { readonly label: string; readonly serviceName?: string }[],
-): DevControlService[] {
-  const seen = new Set<string>();
-  const out: DevControlService[] = [];
-  for (const row of rows) {
-    const name = row.serviceName?.trim();
-    if (!name || seen.has(name)) continue;
-    seen.add(name);
-    out.push({ label: row.label, serviceName: name });
-  }
-  return out;
-}