okengine 0.18.5 → 0.19.0

package/src/docker/compose-up.ts

@@ -0,0 +1,292 @@
+/**
+ * Stream `docker compose up -d` so `oke dev` can show pull / start progress.
+ */
+
+/** Lifecycle phase inferred from a compose progress line. */
+export type ComposeUpPhase =
+  | "pulling"
+  | "pulled"
+  | "creating"
+  | "created"
+  | "starting"
+  | "started"
+  | "waiting"
+  | "healthy"
+  | "downloading"
+  | "extracting"
+  | "error"
+  | "other";
+
+/** One parsed compose progress event (may be activity-only). */
+export type ComposeUpEvent = {
+  /** Raw line with ANSI / CR noise stripped. */
+  readonly raw: string;
+  /** Image / service / container / network name when known. */
+  readonly target?: string;
+  /** Compose resource kind when the line names one. */
+  readonly kind?: "container" | "image" | "network" | "volume" | "service";
+  /** Lifecycle phase when known. */
+  readonly phase?: ComposeUpPhase;
+  /** Extra detail (download bar, error text). */
+  readonly detail?: string;
+};
+
+/** Options for {@link runComposeUp}. */
+export type RunComposeUpOptions = {
+  readonly files: readonly string[];
+  readonly cwd: string;
+  readonly env: Readonly<Record<string, string>>;
+  /** Called for each meaningful progress line (after parse). */
+  readonly onEvent?: (event: ComposeUpEvent) => void;
+};
+
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+
+/**
+ * Strip ANSI escapes and normalize whitespace for parsing / display.
+ *
+ * @param text - Raw chunk or line
+ */
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI_RE, "").replace(/\r/g, "");
+}
+
+/**
+ * Shorten a compose container / image name for status chrome.
+ *
+ * @param name - Full target from compose output
+ */
+export function shortenComposeTarget(name: string): string {
+  const trimmed = name.trim();
+  if (!trimmed) return trimmed;
+  // Image refs: `postgres:16-alpine` / `library/redis:7` → repo leaf
+  if (trimmed.includes(":")) {
+    const repo = trimmed.slice(0, trimmed.indexOf(":"));
+    const slash = repo.lastIndexOf("/");
+    return slash >= 0 ? repo.slice(slash + 1) : repo;
+  }
+  // `oke-<slug>-postgres-1` → `postgres` (drop replica, take last segment)
+  if (/^oke-/i.test(trimmed)) {
+    const noReplica = trimmed.replace(/-\d+$/, "");
+    const parts = noReplica.split("-").filter(Boolean);
+    const leaf = parts[parts.length - 1];
+    if (leaf) return leaf;
+  }
+  return trimmed;
+}
+
+/**
+ * Human label for a compose phase (status line suffix).
+ *
+ * @param phase - Parsed phase
+ */
+export function composeUpPhaseLabel(phase: ComposeUpPhase): string {
+  switch (phase) {
+    case "pulling":
+      return "pulling…";
+    case "pulled":
+      return "pulled";
+    case "creating":
+      return "creating…";
+    case "created":
+      return "created";
+    case "starting":
+      return "starting…";
+    case "started":
+      return "started";
+    case "waiting":
+      return "waiting…";
+    case "healthy":
+      return "healthy";
+    case "downloading":
+      return "downloading…";
+    case "extracting":
+      return "extracting…";
+    case "error":
+      return "error";
+    case "other":
+      return "";
+  }
+}
+
+/**
+ * Map a phase to a boot ● status.
+ *
+ * @param phase - Parsed phase
+ */
+export function composeUpPhaseStatus(phase: ComposeUpPhase): "ready" | "pending" | "error" {
+  if (phase === "error") return "error";
+  if (phase === "pulled" || phase === "created" || phase === "started" || phase === "healthy") {
+    return "ready";
+  }
+  return "pending";
+}
+
+const KIND_PHASE: Record<string, ComposeUpPhase> = {
+  pulling: "pulling",
+  pulled: "pulled",
+  creating: "creating",
+  created: "created",
+  starting: "starting",
+  started: "started",
+  waiting: "waiting",
+  healthy: "healthy",
+  error: "error",
+  errored: "error",
+  failed: "error",
+};
+
+/**
+ * Parse one docker compose progress line into a structured event.
+ *
+ * Handles Compose plain progress (`Image x Pulling`, `Container y Started`)
+ * and common layer download chatter.
+ *
+ * @param line - One logical line (already split on `\n` / `\r`)
+ */
+export function parseComposeProgressLine(line: string): ComposeUpEvent | null {
+  const raw = stripAnsi(line).trim();
+  if (!raw) return null;
+  // Spinner / empty chrome
+  if (/^[.·…]+$/.test(raw)) return null;
+
+  const kinded =
+    /^(Container|Image|Network|Volume|Service)\s+(.+?)\s+(Pulling|Pulled|Creating|Created|Starting|Started|Waiting|Healthy|Error|Errored|Failed)\b/i.exec(
+      raw,
+    );
+  if (kinded?.[1] && kinded[2] && kinded[3]) {
+    const phase = KIND_PHASE[kinded[3].toLowerCase()] ?? "other";
+    const kind = kinded[1].toLowerCase() as ComposeUpEvent["kind"];
+    return { raw, target: kinded[2].trim(), kind, phase };
+  }
+
+  // `postgres Pulling` / `postgres Pulled` (service-keyed)
+  const bare =
+    /^([A-Za-z0-9][A-Za-z0-9._/-]*)\s+(Pulling|Pulled|Creating|Created|Starting|Started|Waiting|Healthy)\b/i.exec(
+      raw,
+    );
+  if (bare?.[1] && bare[2]) {
+    const phase = KIND_PHASE[bare[2].toLowerCase()] ?? "other";
+    return { raw, target: bare[1], phase };
+  }
+
+  if (/\bDownloading\b/i.test(raw) || /\bDownload complete\b/i.test(raw)) {
+    return { raw, phase: "downloading", detail: raw };
+  }
+  if (/\bExtracting\b/i.test(raw) || /\bPull complete\b/i.test(raw)) {
+    return { raw, phase: "extracting", detail: raw };
+  }
+  if (/\b(error|failed|fatal)\b/i.test(raw)) {
+    return { raw, phase: "error", detail: raw };
+  }
+
+  // Keep other non-empty lines as activity so pulls never look frozen.
+  return { raw, phase: "other", detail: raw };
+}
+
+/**
+ * Format a status message for one compose event.
+ *
+ * @param event - Parsed event
+ */
+export function formatComposeUpEventMessage(event: ComposeUpEvent): string {
+  if (event.target && event.phase && event.phase !== "other") {
+    const label = composeUpPhaseLabel(event.phase);
+    const name = shortenComposeTarget(event.target);
+    return label ? `${name} ${label}` : name;
+  }
+  if (event.detail) {
+    // Cap long download bars for the status chrome.
+    const d = event.detail.length > 72 ? `${event.detail.slice(0, 69)}…` : event.detail;
+    return d;
+  }
+  return event.raw.length > 72 ? `${event.raw.slice(0, 69)}…` : event.raw;
+}
+
+/**
+ * Pump a byte stream into logical lines (`\n` and `\r`), invoking `onLine`.
+ *
+ * @param stream - Process stdout/stderr
+ * @param onLine - Per logical line
+ * @param collect - Append raw text for error reporting
+ */
+async function pumpComposeStream(
+  stream: ReadableStream<Uint8Array> | null,
+  onLine: (line: string) => void,
+  collect: (chunk: string) => void,
+): Promise<void> {
+  if (!stream) return;
+  const reader = stream.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const chunk = dec.decode(value, { stream: true });
+    collect(chunk);
+    buf += chunk;
+    // Progress bars use `\r`; treat both as line breaks.
+    for (;;) {
+      const nl = buf.search(/[\r\n]/);
+      if (nl < 0) break;
+      const line = buf.slice(0, nl);
+      const sep = buf[nl];
+      buf = buf.slice(nl + 1);
+      // Swallow the LF of a CRLF pair.
+      if (sep === "\r" && buf.startsWith("\n")) buf = buf.slice(1);
+      if (line.length > 0) onLine(line);
+    }
+  }
+  if (buf.length > 0) onLine(buf);
+}
+
+/**
+ * Run `docker compose … up -d --remove-orphans --progress=plain`, streaming
+ * progress events. Throws when the process exits non-zero.
+ *
+ * @param options - Files, cwd, env, optional event sink
+ */
+export async function runComposeUp(options: RunComposeUpOptions): Promise<void> {
+  const args = [
+    "compose",
+    "--progress",
+    "plain",
+    ...options.files.flatMap((f) => ["-f", f]),
+    "up",
+    "-d",
+    "--remove-orphans",
+  ];
+  const proc = Bun.spawn(["docker", ...args], {
+    cwd: options.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      ...options.env,
+      BUILDKIT_PROGRESS: "plain",
+      COMPOSE_ANSI: "never",
+    },
+  });
+
+  let stdout = "";
+  let stderr = "";
+  const emitLine = (line: string): void => {
+    const event = parseComposeProgressLine(line);
+    if (!event) return;
+    options.onEvent?.(event);
+  };
+
+  await Promise.all([
+    pumpComposeStream(proc.stdout, emitLine, (c) => {
+      stdout += c;
+    }),
+    pumpComposeStream(proc.stderr, emitLine, (c) => {
+      stderr += c;
+    }),
+  ]);
+  const code = await proc.exited;
+  if (code !== 0) {
+    const detail = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+    throw new Error(`oke dev: docker compose exited ${code}` + (detail ? `\n${detail}` : ""));
+  }
+}

package/src/docker/compose.ts

@@ -463,7 +463,7 @@ export function buildStackEnv(
       env.OKE_STORE_INDEX_URL = url;
       env.OKE_STORE_INDEX_KEY = spec.credentials.password;
     } else if (spec.role === "ai") {
-      // Ollama: standalone HTTP URL; model is a stack control (OKE_AI_MODEL).
+      // Unsupported compose role — prefer BYO `OKE_AI_URL` for cloud / local servers.
       env[`${prefix}_URL`] = url;
       env.OKE_AI_URL = url;
     } else if (spec.role === "proxy") {
@@ -508,7 +508,7 @@ const ROLE_SECTION_TITLE: Readonly<Record<string, string>> = {
   "store.index": "store.index — search index",
   "channel.email": "channel.email — Mailpit (SMTP + UI)",
   signal: "signal — message bus",
-  ai: "ai — local inference (llama.cpp / Ollama / vLLM / SGLang)",
+  ai: "ai — (unsupported; use OKE_AI_URL)",
   proxy: "proxy — edge reverse proxy (Caddy / Traefik / nginx)",
 };
 
@@ -561,7 +561,7 @@ const ROLE_ALIASES: Readonly<Record<string, readonly string[]>> = {
     "MP_SMTP_AUTH_ALLOW_INSECURE",
   ],
   // OKE_AI_URL is already emitted as `${prefix}_URL` — do not alias it again.
-  ai: ["OKE_AI_MODEL", "OKE_AI_CTX_SIZE"],
+  ai: [],
   proxy: ["OKE_PROXY_HOST", "OKE_PROXY_ACME_EMAIL"],
   "store.index": ["OKE_STORE_INDEX_KEY"],
 };
@@ -578,11 +578,6 @@ const ROLE_CONTROL_EXAMPLES: Readonly<Record<string, readonly string[]>> = {
     "MP_SMTP_AUTH_ACCEPT_ANY=1",
     "MP_SMTP_AUTH_ALLOW_INSECURE=1",
   ],
-  // Curated Docker Hub `ai/` model id for llama.cpp; Ollama tags differ.
-  // OKE_AI_CTX_SIZE bounds the KV cache llama-server allocates at load —
-  // left at the model's full native context (often 32K-256K+), a small
-  // model's KV cache alone can OOM the container regardless of host RAM.
-  ai: ["OKE_AI_MODEL=granite3.3:2b", "OKE_AI_CTX_SIZE=4096"],
   proxy: ["OKE_PROXY_HOST=localhost", "OKE_PROXY_ACME_EMAIL=admin@example.com"],
 };
 
@@ -600,12 +595,7 @@ function roleFromEnvKey(key: string): string | undefined {
   }
   if (key === "PGDATA" || key === "POSTGRES_INITDB_ARGS") return "store.sql";
   if (key.startsWith("OKE_STORE_KV_MAXMEMORY")) return "store.kv";
-  if (
-    key === "OKE_AI_URL" ||
-    key === "OKE_AI_MODEL" ||
-    key === "OKE_AI_CTX_SIZE" ||
-    key === "OLLAMA_HOST"
-  ) {
+  if (key === "OKE_AI_URL" || key === "OKE_AI_MODEL") {
     return "ai";
   }
   if (key === "OKE_PROXY_URL" || key === "OKE_PROXY_HOST" || key === "OKE_PROXY_ACME_EMAIL") {

package/src/docker/derive.ts

@@ -17,12 +17,6 @@ import {
 import { emitDockerfile } from "./dockerfile.ts";
 import { buildCaddyfile } from "./recipes/caddy.ts";
 import { buildNginxConf } from "./recipes/nginx.ts";
-import {
-  buildLlamaCppEntrypoint,
-  LLAMA_CPP_ENTRYPOINT_FILE,
-  LLAMA_CPP_ENTRYPOINT_HOST_PATH,
-  llamaCpp,
-} from "./recipes/llama-cpp.ts";
 import { buildPgDogToml, buildPgDogUsersToml, PGDOG_CONFIG_DIR } from "./recipes/pgdog.ts";
 import {
   emitPostgresAdvisorDockerfile,
@@ -33,6 +27,9 @@ import type { DeriveOptions, DeriveResult, GeneratedFile } from "./types.ts";
 import { DEFAULT_DOCKER_DIR } from "./types.ts";
 import { APP_PORT } from "../runtime/types.ts";
 
+/** Legacy llama.cpp entrypoint path (relative to compose dir) — pruned once. */
+const LEGACY_LLAMA_ENTRYPOINT_HOST_PATH = "../.oke/llama-entrypoint.py";
+
 /**
  * Derive infrastructure files from normalised image pins.
  *
@@ -76,7 +73,6 @@ export function deriveInfrastructure(options: DeriveOptions): DeriveResult {
     ...composeFilesContent,
     ...pgdogConfigFiles(specs),
     ...proxyConfigFiles(specs, normalised.appPort),
-    ...llamaCppEntrypointFiles(specs),
     ...postgresAdvisorDockerfileFiles(specs),
   ];
 
@@ -112,25 +108,6 @@ function postgresAdvisorDockerfileFiles(specs: DeriveResult["specs"]): Generated
   ];
 }
 
-/**
- * Emit `.oke/llama-entrypoint.py` (path relative to compose dir) when the AI
- * role is llama.cpp so first boot can Hub-pull then serve single-model
- * (router `--docker-repo` hangs on b10290+). Kept out of `docker/` so app
- * trees stay TypeScript-only.
- *
- * @param specs - Normalised services
- */
-function llamaCppEntrypointFiles(specs: DeriveResult["specs"]): GeneratedFile[] {
-  const ai = specs.find((s) => s.role === "ai");
-  if (!ai || !llamaCpp.match(ai.image)) return [];
-  return [
-    {
-      path: LLAMA_CPP_ENTRYPOINT_HOST_PATH,
-      content: buildLlamaCppEntrypoint(),
-    },
-  ];
-}
-
 /**
  * Emit PgDog TOML configs when both `pgdog` and `store.sql` are in the stack.
  *
@@ -208,7 +185,7 @@ export async function writeDerivedFiles(
   mkdirSync(root, { recursive: true });
   const keep = new Set(result.files.map((f) => f.path));
   pruneStaleGenerated(root, keep);
-  pruneLlamaEntrypoint(root, keep);
+  pruneLegacyLlamaEntrypoint(root);
   for (const file of result.files) {
     const path = join(root, file.path);
     mkdirSync(dirname(path), { recursive: true });
@@ -255,21 +232,19 @@ const PRUNE_ROOT_FILES = new Set([
   "compose.prod.yml",
   "Caddyfile",
   "nginx.conf",
-  // Legacy: entrypoint used to land in `docker/`; now `.oke/` only.
-  LLAMA_CPP_ENTRYPOINT_FILE,
+  // Legacy: llama.cpp entrypoint used to land in `docker/`.
+  "llama-entrypoint.py",
   "pgdog.toml",
   "users.toml",
 ]);
 
 /**
- * Drop `.oke/llama-entrypoint.py` when the stack no longer uses llama.cpp.
+ * Drop stale `.oke/llama-entrypoint.py` from older stacks (AI recipes removed).
  *
  * @param root - Compose directory (`docker/`)
- * @param keep - Relative paths that will be rewritten
  */
-function pruneLlamaEntrypoint(root: string, keep: ReadonlySet<string>): void {
-  if (keep.has(LLAMA_CPP_ENTRYPOINT_HOST_PATH)) return;
-  const abs = join(root, LLAMA_CPP_ENTRYPOINT_HOST_PATH);
+function pruneLegacyLlamaEntrypoint(root: string): void {
+  const abs = join(root, LEGACY_LLAMA_ENTRYPOINT_HOST_PATH);
   try {
     unlinkSync(abs);
   } catch {