create-oke 0.18.4 → 0.19.0

package/templates/standard/src/flows/notes/[id]/get.ts

@@ -2,15 +2,12 @@ import { on, flow, http, fail } from "okengine/http";
 
 import { db } from "@/core";
 import { notes } from "@/db/schema.decl";
-import { NoteIdIn, NoteOut, NotFound } from "../shapes";
+import { NoteIdIn, NoteOut, NotFound, toIsoInstant } from "../shapes";
 
 /** Fetch one note by id. */
 export const get = on(
-  http.get().public(),
+  http.get({ in: NoteIdIn, out: NoteOut, errors: { NotFound } }).public(),
   flow({
-    in: NoteIdIn,
-    out: NoteOut,
-    errors: { NotFound },
     do: async (input, fx) => {
       const row = await fx.store(db).findById(notes, input.id);
       if (!row) return fail("NotFound", { id: input.id });
@@ -18,8 +15,8 @@ export const get = on(
         id: String(row.id),
         title: String(row.title),
         body: String(row.body),
-        archivedAt: row.archivedAt == null ? null : Number(row.archivedAt),
-        createdAt: Number(row.createdAt),
+        archivedAt: row.archivedAt == null ? null : toIsoInstant(row.archivedAt),
+        createdAt: toIsoInstant(row.createdAt),
       };
     },
   }),

package/templates/standard/src/flows/notes/create.ts

@@ -2,19 +2,17 @@ import { on, flow, http } from "okengine/http";
 
 import { db, notesMutate, webhookSecret } from "@/core";
 import { notes } from "@/db/schema.decl";
-import { NoteCreateIn, NoteOut } from "./shapes";
+import { NoteCreateIn, NoteOut, toIsoInstant } from "./shapes";
 import { noteCreated } from "./signals";
 
 /** Create a note, emit `note-created`, touch vault. */
 export const create = on(
-  http.post().gate(notesMutate),
+  http.post({ in: NoteCreateIn, out: NoteOut }).gate(notesMutate),
   flow({
-    in: NoteCreateIn,
-    out: NoteOut,
     do: async (input, fx) => {
       await fx.vault.get(webhookSecret);
       const id = fx.id();
-      const createdAt = fx.clock.now();
+      const createdAt = new Date(fx.clock.now());
       await fx.store(db).insert(notes).values({
         id,
         title: input.title,
@@ -28,7 +26,7 @@ export const create = on(
         title: input.title,
         body: input.body,
         archivedAt: null,
-        createdAt,
+        createdAt: toIsoInstant(createdAt),
       };
     },
   }),

package/templates/standard/src/flows/notes/list.ts

@@ -3,13 +3,12 @@ import { isNull } from "drizzle-orm";
 
 import { db } from "@/core";
 import { notes } from "@/db/schema.decl";
-import { NoteListOut } from "./shapes";
+import { NoteListOut, toIsoInstant } from "./shapes";
 
 /** List active (non-archived) notes, newest first. */
 export const list = on(
-  http.get().public(),
+  http.get({ out: NoteListOut }).public(),
   flow({
-    out: NoteListOut,
     do: async (input, fx) => {
       const rows = await fx.store(db).select().from(notes).where(isNull(notes.archivedAt));
       const data = [...rows]
@@ -18,8 +17,8 @@ export const list = on(
           id: String(r.id),
           title: String(r.title),
           body: String(r.body),
-          archivedAt: r.archivedAt == null ? null : Number(r.archivedAt),
-          createdAt: Number(r.createdAt),
+          archivedAt: r.archivedAt == null ? null : toIsoInstant(r.archivedAt),
+          createdAt: toIsoInstant(r.createdAt),
         }));
       return fx.json.withQuery(data, input);
     },

package/templates/standard/src/flows/notes/shapes.ts

@@ -1,5 +1,8 @@
 import { z } from "zod";
 
+/** Instant on the HTTP wire — ISO-8601 UTC. */
+export const IsoInstant = z.iso.datetime();
+
 export const NoteCreateIn = z.object({
   title: z.string().min(1).max(200),
   body: z.string().min(1).max(10_000),
@@ -9,8 +12,8 @@ export const NoteOut = z.object({
   id: z.string(),
   title: z.string(),
   body: z.string(),
-  archivedAt: z.number().nullable(),
-  createdAt: z.number(),
+  archivedAt: IsoInstant.nullable(),
+  createdAt: IsoInstant,
 });
 
 /** List `data` is the item array. Pagination lives in HTTP `meta`. */
@@ -23,3 +26,10 @@ export const NoteIdIn = z.object({
 export const NotFound = z.object({
   id: z.string(),
 });
+
+/** Map a store temporal (`Date` / ISO / epoch-ms) to an ISO wire string. */
+export function toIsoInstant(value: unknown): string {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return new Date(value).toISOString();
+  return new Date(Number(value)).toISOString();
+}

package/templates/standard/src/flows/notes/signals.ts

@@ -2,8 +2,7 @@ import { signal } from "okengine";
 import { z } from "zod";
 
 /** Fired after a note is persisted — subscriber sends email. */
-export const noteCreated = signal("note-created", {
-  delivery: "once",
+export const noteCreated = signal.once("note-created", {
   retries: 3,
   deadLetter: true,
   schema: z.object({

package/templates/standard/src/vault.ts

@@ -0,0 +1,123 @@
+/**
+ * Notes vault contracts — secrets and cleartext config.
+ *
+ * Values resolve through the driver chain (built-in store → process.env →
+ * `.env.local` → `dev:` / `vault.fromDocker`). Declare every stack / app name
+ * here so Console Vault lists it; put values in `.env.local`, `oke vault set`,
+ * or leave the local fallback for Docker-first `oke dev`.
+ */
+
+import { vault } from "okengine";
+
+// --- Secrets (fingerprinted) -------------------------------------------------
+
+/** HMAC secret for outbound note webhooks (`fx.vault.get` on create). */
+export const webhookSecret = vault.secret("APP_WEBHOOK_SECRET", {
+  description: "HMAC secret for outbound note webhooks",
+  rotate: "never",
+  dev: "dev-webhook-secret-change-me",
+});
+
+/** Console operator secret. */
+export const okeConsoleSecret = vault.secret("OKE_CONSOLE_SECRET", {
+  description: "Console operator secret",
+  rotate: "90d",
+  dev: "oke-dev-notes-console",
+});
+
+/** Mailpit SMTP URL. */
+export const channelEmailUrl = vault.secret("OKE_CHANNEL_EMAIL_URL", {
+  description: "Mailpit SMTP URL",
+  rotate: "never",
+  dev: vault.fromDocker("channel.email"),
+});
+
+/** SMTP alias. */
+export const smtpUrl = vault.secret("SMTP_URL", {
+  description: "SMTP URL",
+  rotate: "never",
+  dev: vault.fromDocker("channel.email"),
+});
+
+/** Object storage URL. */
+export const storeFilesUrl = vault.secret("OKE_STORE_FILES_URL", {
+  description: "Object storage URL",
+  rotate: "never",
+  dev: vault.fromDocker("store.files"),
+});
+
+/** Redis URL. */
+export const storeKvUrl = vault.secret("OKE_STORE_KV_URL", {
+  description: "Redis URL",
+  rotate: "never",
+  dev: vault.fromDocker("store.kv"),
+});
+
+/** Redis alias. */
+export const redisUrl = vault.secret("REDIS_URL", {
+  description: "Redis URL",
+  rotate: "never",
+  dev: vault.fromDocker("store.kv"),
+});
+
+/** Direct Postgres URL. */
+export const storeSqlUrl = vault.secret("OKE_STORE_SQL_URL", {
+  description: "Direct Postgres URL",
+  rotate: "never",
+  dev: vault.fromDocker("store.sql"),
+});
+
+/** Postgres URL (compose / PgDog may rewrite this). */
+export const databaseUrl = vault.secret("DATABASE_URL", {
+  description: "Postgres URL",
+  rotate: "never",
+  dev: vault.fromDocker("store.sql"),
+});
+
+// --- Config (shown in the clear) ---------------------------------------------
+
+/** App listen origin. */
+export const okeAppUrl = vault.config("OKE_APP_URL", {
+  description: "App listen origin",
+  dev: "http://127.0.0.1:6530",
+});
+
+/** Public API origin (Vite web keeps `VITE_API_URL` empty for same-origin proxy). */
+export const publicApiUrl = vault.config("PUBLIC_API_URL", {
+  description: "Public API origin",
+  dev: "http://127.0.0.1:6530",
+});
+
+/** Mailpit UI origin. */
+export const mailpitUiUrl = vault.config("MAILPIT_UI_URL", {
+  description: "Mailpit UI origin",
+  dev: "http://127.0.0.1:8025",
+});
+
+/** Maintenance flag (`1` / `0`). */
+export const maintenanceMode = vault.config("MAINTENANCE_MODE", {
+  description: "Maintenance mode flag",
+  dev: "0",
+});
+
+/**
+ * Full contract list for `oke({ secrets })`.
+ *
+ * `vault.secret` auto-registers; `vault.config` does not — pass this array so
+ * configs resolve in boot / Console the same way secrets do.
+ */
+export const NOTES_VAULT = [
+  webhookSecret,
+  okeConsoleSecret,
+  channelEmailUrl,
+  smtpUrl,
+  storeFilesUrl,
+  storeKvUrl,
+  redisUrl,
+  storeSqlUrl,
+  databaseUrl,
+  okeAppUrl,
+  publicApiUrl,
+  mailpitUiUrl,
+  maintenanceMode,
+] as const;

package/templates/standard/tests/standard.test.ts

@@ -39,7 +39,9 @@ test("notes create → list → archive", async () => {
 
   const archived = await t.api.notes!.archive!({ id: row.id });
   expect(archived.error).toBeNull();
-  expect((archived.data as { archivedAt: number }).archivedAt).toBeTypeOf("number");
+  const archivedAt = (archived.data as { archivedAt: string }).archivedAt;
+  expect(archivedAt).toBeTypeOf("string");
+  expect(Number.isNaN(Date.parse(archivedAt))).toBe(false);
 
   const after = await t.api.notes!.list!({});
   const afterNotes = after.data as { id: string }[];

package/templates/standard/web/src/client.ts

@@ -12,8 +12,8 @@ export type Note = {
   readonly id: string;
   readonly title: string;
   readonly body: string;
-  readonly archivedAt: number | null;
-  readonly createdAt: number;
+  readonly archivedAt: string | null;
+  readonly createdAt: string;
 };
 
 const $routes = {

package/templates/standard/web/vite.config.ts

@@ -20,6 +20,7 @@ const APP_ORIGIN = "http://127.0.0.1:6530";
 const proxy: Record<string, ProxyOptions> = {
   "/health": { target: APP_ORIGIN, changeOrigin: true },
   "/notes": { target: APP_ORIGIN, changeOrigin: true },
+  "/auth": { target: APP_ORIGIN, changeOrigin: true },
   "/_oke": { target: APP_ORIGIN, changeOrigin: true },
 };
 

package/src/ai-setup/detect-ollama.ts

@@ -1,228 +0,0 @@
-/**
- * Detect local Ollama — CLI (`ollama list` / `ps`) and HTTP `/api/tags`.
- */
-
-import { ALL_CURATED, type CatalogModel } from "./catalog.ts";
-
-/** Default Ollama HTTP origin (create-oke copy — no okengine driver import). */
-const OLLAMA_DEFAULT_BASE_URL = "http://127.0.0.1:11434";
-
-/**
- * Normalize an Ollama base URL (strip trailing slash / accidental `/v1`).
- *
- * @param raw - User or env value
- */
-function normalizeOllamaBaseUrl(raw: string): string {
-  const trimmed = raw.trim().replace(/\/$/, "");
-  if (!trimmed) return OLLAMA_DEFAULT_BASE_URL;
-  if (/^https?:\/\//i.test(trimmed)) return trimmed.replace(/\/v1\/?$/i, "");
-  return `http://${trimmed}`;
-}
-
-/** Result of probing the local Ollama install. */
-export type OllamaDetectResult = {
-  readonly available: boolean;
-  readonly baseUrl: string;
-  readonly installed: readonly string[];
-  readonly running: readonly string[];
-  readonly curatedInstalled: readonly CatalogModel[];
-  readonly curatedMissing: readonly CatalogModel[];
-};
-
-/**
- * Parse `ollama list` tabular output into model names.
- *
- * @param stdout - CLI stdout
- */
-export function parseOllamaList(stdout: string): string[] {
-  const lines = stdout
-    .split("\n")
-    .map((l) => l.trim())
-    .filter(Boolean);
-  const out: string[] = [];
-  for (const line of lines) {
-    if (/^NAME\b/i.test(line)) continue;
-    const name = line.split(/\s+/)[0];
-    if (name) out.push(name);
-  }
-  return out;
-}
-
-/**
- * Parse `ollama ps` tabular output into running model names.
- *
- * @param stdout - CLI stdout
- */
-export function parseOllamaPs(stdout: string): string[] {
-  return parseOllamaList(stdout);
-}
-
-/**
- * Normalize installed tag for comparison (`qwen3.5:9b` vs `qwen3.5:9b-mlx`).
- *
- * @param id - Catalog or installed id
- * @param installed - Installed names
- */
-export function isInstalled(id: string, installed: readonly string[]): boolean {
-  const base = id.split(":")[0] ?? id;
-  return installed.some((name) => {
-    if (name === id) return true;
-    if (name.startsWith(`${id}-`)) return true;
-    if (name.startsWith(`${base}:`) && id.startsWith(`${base}:`)) {
-      // treat mlx / quant suffixes as matching the same family:tag when prefix matches
-      const instTag = name.slice(base.length + 1);
-      const wantTag = id.slice(base.length + 1);
-      return (
-        instTag === wantTag || instTag.startsWith(`${wantTag}-`) || wantTag.startsWith(instTag)
-      );
-    }
-    return false;
-  });
-}
-
-/**
- * Detect Ollama via CLI then HTTP fallback.
- *
- * @param options - Base URL / spawn / fetch seams
- */
-export async function detectOllama(
-  options: {
-    readonly baseUrl?: string;
-    readonly fetch?: typeof globalThis.fetch;
-    readonly run?: (cmd: readonly string[]) => Promise<{ code: number; stdout: string }>;
-  } = {},
-): Promise<OllamaDetectResult> {
-  const baseUrl = normalizeOllamaBaseUrl(options.baseUrl ?? OLLAMA_DEFAULT_BASE_URL);
-  const run =
-    options.run ??
-    (async (cmd) => {
-      const proc = Bun.spawn([...cmd], { stdout: "pipe", stderr: "pipe" });
-      const stdout = await new Response(proc.stdout).text();
-      const code = await proc.exited;
-      return { code, stdout };
-    });
-
-  let installed: string[] = [];
-  let running: string[] = [];
-  let available = false;
-
-  try {
-    const list = await run(["ollama", "list"]);
-    if (list.code === 0) {
-      available = true;
-      installed = parseOllamaList(list.stdout);
-    }
-    const ps = await run(["ollama", "ps"]);
-    if (ps.code === 0) {
-      running = parseOllamaPs(ps.stdout);
-    }
-  } catch {
-    // CLI missing — try HTTP
-  }
-
-  if (!available) {
-    const fetchFn = options.fetch ?? globalThis.fetch;
-    try {
-      const res = await fetchFn(`${baseUrl}/api/tags`, {
-        method: "GET",
-        signal: AbortSignal.timeout(2_000),
-      });
-      if (res.ok) {
-        available = true;
-        const json = (await res.json()) as { models?: readonly { name?: string }[] };
-        installed = (json.models ?? [])
-          .map((m) => m.name)
-          .filter((n): n is string => typeof n === "string");
-      }
-    } catch {
-      // unavailable
-    }
-  }
-
-  const curatedInstalled = ALL_CURATED.filter((m) => isInstalled(m.id, installed));
-  const curatedMissing = ALL_CURATED.filter((m) => !isInstalled(m.id, installed));
-
-  return {
-    available,
-    baseUrl,
-    installed,
-    running,
-    curatedInstalled,
-    curatedMissing,
-  };
-}
-
-/** Detected host hardware for the Ollama banner. */
-export type MachineInfo = {
-  readonly osName: string;
-  readonly cpuCount: number | null;
-  readonly ramGb: number | null;
-};
-
-/**
- * Best-effort total system RAM in GB.
- */
-export function detectTotalRamGb(): number | null {
-  try {
-    if (process.platform === "darwin") {
-      const proc = Bun.spawnSync(["sysctl", "-n", "hw.memsize"], { stdout: "pipe" });
-      if (proc.exitCode === 0) {
-        const bytes = Number(proc.stdout.toString().trim());
-        if (Number.isFinite(bytes) && bytes > 0) return Math.round(bytes / 1024 ** 3);
-      }
-    }
-    if (process.platform === "linux") {
-      const proc = Bun.spawnSync(["awk", "/MemTotal/ {print $2}", "/proc/meminfo"], {
-        stdout: "pipe",
-      });
-      if (proc.exitCode === 0) {
-        const kb = Number(proc.stdout.toString().trim());
-        if (Number.isFinite(kb) && kb > 0) return Math.round(kb / 1024 ** 2);
-      }
-    }
-  } catch {
-    // ignore
-  }
-  return null;
-}
-
-/**
- * Best-effort OS name · CPU count · RAM for the Ollama banner.
- */
-export function detectMachineInfo(): MachineInfo {
-  const osName =
-    process.platform === "darwin"
-      ? "macOS"
-      : process.platform === "linux"
-        ? "Linux"
-        : process.platform === "win32"
-          ? "Windows"
-          : process.platform;
-
-  let cpuCount: number | null = null;
-  try {
-    if (process.platform === "darwin") {
-      const proc = Bun.spawnSync(["sysctl", "-n", "hw.ncpu"], { stdout: "pipe" });
-      if (proc.exitCode === 0) {
-        const n = Number(proc.stdout.toString().trim());
-        if (Number.isFinite(n) && n > 0) cpuCount = n;
-      }
-    } else if (typeof navigator !== "undefined" && "hardwareConcurrency" in navigator) {
-      const n = Number(navigator.hardwareConcurrency);
-      if (Number.isFinite(n) && n > 0) cpuCount = n;
-    }
-  } catch {
-    // ignore
-  }
-  if (cpuCount === null) {
-    try {
-      // Bun / Node expose this on process when available
-      const n = (process as { availableParallelism?: () => number }).availableParallelism?.();
-      if (typeof n === "number" && Number.isFinite(n) && n > 0) cpuCount = n;
-    } catch {
-      // ignore
-    }
-  }
-
-  return { osName, cpuCount, ramGb: detectTotalRamGb() };
-}