@omg-dev/vite-plugin 0.4.24

package/src/build.ts

@@ -0,0 +1,430 @@
+#!/usr/bin/env bun
+// vibes-build — produces a self-contained deploy artifact set.
+//
+// What this emits, relative to app root:
+//   dist/               — vite client build
+//   .vibes/data.db      — sqlite seeded with the schema (migrations ran here,
+//                          not at runtime; runtime only registers scopes)
+//   .vibes/server.mjs   — single-file bundled server (functions + @omg-dev/*
+//                          inlined via bun build --target=bun). No node_modules
+//                          needed at runtime.
+//   .vibes/artifacts.json — manifest consumed by the orchestrator bundle-copy
+//                          phase; lists every path that must ship to the
+//                          runtime sandbox.
+//
+// Why split migration off runtime:
+//   migrate() re-opens the DB and diffs sqlite_master on every cold start. For
+//   scale-to-zero deploys that adds 10–50ms per wake-up and — more importantly —
+//   makes the runtime care about schema.ts, which means the runtime needs the
+//   schema file, its transitive @omg-dev/schema dep, and bun's module resolver.
+//   Running it at build time against .vibes/data.db means the runtime just
+//   opens a pre-seeded sqlite file.
+//
+// Why bundle functions via codegen (not dynamic import at runtime):
+//   packages/server's dispatcher previously did `await import(route.module)` —
+//   that path would have to exist in the runtime sandbox AND pull in each
+//   function's transitive deps from node_modules. Instead we codegen a
+//   .vibes/routes.generated.ts with `import * as entries from ".../entries.ts"`
+//   and hand the dispatcher preloaded module objects. bun build inlines the
+//   lot. Cost: runtime can't hot-swap functions (fine — that's a dev concern).
+
+import fs from "node:fs"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import { scanFunctions } from "./scanner.ts"
+import { scanTriggers } from "./scanner-triggers.ts"
+import { scanWorkflows } from "./scanner-workflows.ts"
+import { scanBilling } from "./scanner-billing.ts"
+import { generateAll } from "./codegen.ts"
+import { prerenderApp } from "./prerender.ts"
+
+const root = process.cwd()
+const vibesDir = path.join(root, ".vibes")
+const distDir = path.join(root, "dist")
+
+function log(msg: string) {
+  console.log(`[vibes-build] ${msg}`)
+}
+
+function die(msg: string): never {
+  console.error(`[vibes-build] FATAL: ${msg}`)
+  process.exit(1)
+}
+
+async function main() {
+  // Sanity — schema.ts must exist, since both the seed step and the server
+  // entry rely on it.
+  const schemaPath = path.join(root, "schema.ts")
+  if (!fs.existsSync(schemaPath)) die("schema.ts not found at root")
+
+  fs.mkdirSync(vibesDir, { recursive: true })
+
+  // ── 1. codegen (types, zod, routes.json) ──────────────────────────────────
+  log("1/5 codegen")
+  await generateAll(root)
+
+  // ── 2. enumerate functions and write routes.generated.ts ──────────────────
+  log("2/5 generating .vibes/routes.generated.ts")
+  const routes = await scanFunctions(root)
+
+  // Group by module so we emit one `import * as X from "..."` per file and
+  // reuse the namespace object across each exported handler.
+  const moduleToAlias = new Map<string, string>()
+  for (const r of routes) {
+    if (!moduleToAlias.has(r.module)) {
+      const base = path.basename(r.module, ".ts").replace(/[^a-zA-Z0-9_]/g, "_")
+      moduleToAlias.set(r.module, `fn_${base}`)
+    }
+  }
+
+  const lines: string[] = [
+    "// AUTO-GENERATED by @omg-dev/vite-plugin. Do not edit.",
+    "// Bundled into .vibes/server.mjs at build time; runtime dispatcher",
+    "// reads route.mod directly — no dynamic import() happens at runtime.",
+    "",
+  ]
+  for (const [modPath, alias] of moduleToAlias) {
+    const rel = relFromVibes(modPath)
+    lines.push(`import * as ${alias} from "${rel}"`)
+  }
+  lines.push("")
+  lines.push("export const routes = [")
+  for (const r of routes) {
+    const alias = moduleToAlias.get(r.module)!
+    const stylePart = r.style ? `, style: ${JSON.stringify(r.style)}` : ""
+    lines.push(
+      `  { method: ${JSON.stringify(r.method)}, path: ${JSON.stringify(r.path)}, ` +
+        `handler: ${JSON.stringify(r.handler)}, module: ${JSON.stringify(r.module)}${stylePart}, mod: ${alias} },`
+    )
+  }
+  lines.push("]")
+  lines.push("")
+  fs.writeFileSync(path.join(vibesDir, "routes.generated.ts"), lines.join("\n"))
+
+  // ── 2b. enumerate triggers and write triggers.generated.ts ────────────────
+  // Same shape as routes.generated.ts so the runtime registry doesn't have
+  // to dynamic-import handler modules — those paths are build-time
+  // absolutes and won't resolve in the bundled .vibes/server.mjs at runtime.
+  // Without this, prod deploys log "unknown handler: <name>" for every
+  // dispatch even though .vibes/triggers.json contains the entry.
+  log("2b/5 generating .vibes/triggers.generated.ts")
+  const triggers = await scanTriggers(root)
+  const trigModuleToAlias = new Map<string, string>()
+  for (const t of triggers) {
+    if (!trigModuleToAlias.has(t.module)) {
+      const base = path.basename(t.module, ".ts").replace(/[^a-zA-Z0-9_]/g, "_")
+      // Prefix differently from routes to avoid name collision in
+      // edge case where a file is BOTH a route module AND a trigger
+      // module (unlikely but harmless to namespace).
+      trigModuleToAlias.set(t.module, `trg_${base}`)
+    }
+  }
+  const trigLines: string[] = [
+    "// AUTO-GENERATED by @omg-dev/vite-plugin. Do not edit.",
+    "// Bundled into .vibes/server.mjs at build time; runtime registry reads",
+    "// entry.mod directly — no dynamic import() happens at runtime.",
+    "",
+  ]
+  for (const [modPath, alias] of trigModuleToAlias) {
+    const rel = relFromVibes(modPath)
+    trigLines.push(`import * as ${alias} from "${rel}"`)
+  }
+  trigLines.push("")
+  trigLines.push("export const triggers = [")
+  for (const t of triggers) {
+    const alias = trigModuleToAlias.get(t.module)!
+    trigLines.push(
+      `  { handler: ${JSON.stringify(t.handler)}, kind: ${JSON.stringify(t.kind)}, ` +
+        `key: ${JSON.stringify(t.key)}, module: ${JSON.stringify(t.module)}, ` +
+        `exportName: ${JSON.stringify(t.exportName)}, mod: ${alias} },`,
+    )
+  }
+  trigLines.push("]")
+  trigLines.push("")
+  fs.writeFileSync(path.join(vibesDir, "triggers.generated.ts"), trigLines.join("\n"))
+
+  // ── 2c. enumerate workflows and write workflows.generated.ts ──────────────
+  // Same preloaded-`mod` pattern as triggers: the bundled runtime must not
+  // dynamic-import build-time absolute paths. Scan throws on malformed
+  // declarations (non-literal / duplicate names) and fails the build loud.
+  log("2c/5 generating .vibes/workflows.generated.ts")
+  const workflows = await scanWorkflows(root)
+  const wfModuleToAlias = new Map<string, string>()
+  for (const w of workflows) {
+    if (!wfModuleToAlias.has(w.module)) {
+      const base = path.basename(w.module, ".ts").replace(/[^a-zA-Z0-9_]/g, "_")
+      wfModuleToAlias.set(w.module, `wf_${base}`)
+    }
+  }
+  const wfLines: string[] = [
+    "// AUTO-GENERATED by @omg-dev/vite-plugin. Do not edit.",
+    "// Bundled into .vibes/server.mjs at build time; runtime registry reads",
+    "// entry.mod directly — no dynamic import() happens at runtime.",
+    "",
+  ]
+  for (const [modPath, alias] of wfModuleToAlias) {
+    const rel = relFromVibes(modPath)
+    wfLines.push(`import * as ${alias} from "${rel}"`)
+  }
+  wfLines.push("")
+  wfLines.push("export const workflows = [")
+  for (const w of workflows) {
+    const alias = wfModuleToAlias.get(w.module)!
+    wfLines.push(
+      `  { name: ${JSON.stringify(w.name)}, handler: ${JSON.stringify(w.handler)}, ` +
+        `module: ${JSON.stringify(w.module)}, exportName: ${JSON.stringify(w.exportName)}, mod: ${alias} },`,
+    )
+  }
+  wfLines.push("]")
+  wfLines.push("")
+  fs.writeFileSync(path.join(vibesDir, "workflows.generated.ts"), wfLines.join("\n"))
+
+  // ── 3. write server.entry.ts ──────────────────────────────────────────────
+  log("3/5 generating .vibes/server.entry.ts")
+  const entry = [
+    "// AUTO-GENERATED by @omg-dev/vite-plugin. Do not edit.",
+    "// This is the bundle input for bun build. After bundling, runtime runs",
+    "// `bun .vibes/server.mjs` with no node_modules on disk.",
+    "",
+    'import { createVibesServer, addClient, removeClient, addSubClient, removeSubClient, handleSubMessage } from "@omg-dev/server"',
+    'import { createAuthMiddleware } from "@omg-dev/auth"',
+    'import schema from "../schema.ts"',
+    'import { routes } from "./routes.generated.ts"',
+    'import { triggers } from "./triggers.generated.ts"',
+    'import { workflows } from "./workflows.generated.ts"',
+    "",
+    "const PORT = Number(process.env.PORT) || 3000",
+    "",
+    "const vibes = await createVibesServer({",
+    "  root: process.cwd(),",
+    '  db: ".vibes/data.db",',
+    '  auth: "vibes",',
+    "  schema,",
+    "  routes,",
+    "  triggers,",
+    "  workflows,",
+    "  staticDir: \"dist\",",
+    "  // Migrations run at runtime (idempotent — diffs sqlite_master) so",
+    "  // user data in .vibes/data.db persists across redeploys. The build",
+    "  // artifact intentionally does NOT ship a seeded DB.",
+    "})",
+    "",
+    '// Parallel auth middleware for WS upgrades — vibes.fetch() runs its',
+    '// own authMW inside apiHandler, but the WS path goes through srv.upgrade',
+    '// which never sees apiHandler, so we verify here. Same "vibes" mode.',
+    'const subAuthMW = createAuthMiddleware("vibes")',
+    "",
+    "const server = Bun.serve({",
+    "  port: PORT,",
+    '  hostname: "0.0.0.0",',
+    "  async fetch(req, srv) {",
+    "    const url = new URL(req.url)",
+    '    if (url.pathname === "/__vibes_sub") {',
+    "      // Authenticate the upgrade via the Sec-WebSocket-Protocol header",
+    "      // (the only header browsers let JS clients add to a WS handshake).",
+    "      // Subprotocol of the form `vibes-bearer.<jwt>` carries the JWT;",
+    "      // we verify it via @omg-dev/auth and stash userId on ws.data.ctx.",
+    "      // If verification fails or no token is present, ctx.userId stays",
+    "      // null and the snapshot layer rejects scoped-collection subs.",
+    "      const protoHeader = req.headers.get(\"sec-websocket-protocol\") ?? \"\"",
+    "      const protos = protoHeader.split(\",\").map(s => s.trim()).filter(Boolean)",
+    "      const bearerProto = protos.find(p => p.startsWith(\"vibes-bearer.\"))",
+    "      let userId = null",
+    "      if (bearerProto) {",
+    "        const token = bearerProto.slice(\"vibes-bearer.\".length)",
+    "        try {",
+    "          const fakeReq = new Request(req.url, { headers: { authorization: `Bearer ${token}` } })",
+    "          const result = await subAuthMW(fakeReq)",
+    "          userId = result?.userId ?? null",
+    "        } catch {",
+    "          // Invalid / expired token = anonymous upgrade.",
+    "        }",
+    "      }",
+    "      const headers = bearerProto ? { \"sec-websocket-protocol\": bearerProto } : undefined",
+    "      const ok = srv.upgrade(req, { data: { ctx: { userId } }, headers })",
+    '      return ok ? undefined : new Response("upgrade failed", { status: 400 })',
+    "    }",
+    '    if (url.pathname === "/__vibes_events") {',
+    "      // Heartbeat keeps tunnel + CF edge from idle-closing the stream.",
+    "      // Without it ~100s of silence drops the conn and the SDK reconnects",
+    "      // forever, generating thousands of self-requests per day.",
+    "      const HEARTBEAT_MS = 20000",
+    "      let heartbeat = null",
+    "      const encoder = new TextEncoder()",
+    "      const client = { readyState: 1, send(_d) {} }",
+    "      const cleanup = () => {",
+    "        client.readyState = 3",
+    "        removeClient(client)",
+    "        if (heartbeat) { clearInterval(heartbeat); heartbeat = null }",
+    "      }",
+    "      return new Response(",
+    "        new ReadableStream({",
+    "          start(controller) {",
+    "            try { controller.enqueue(encoder.encode(\":\\n\\n\")) } catch {}",
+    "            client.send = (data) => {",
+    "              try { controller.enqueue(encoder.encode(`data: ${data}\\n\\n`)) }",
+    "              catch { cleanup() }",
+    "            }",
+    "            addClient(client)",
+    "            heartbeat = setInterval(() => {",
+    "              try { controller.enqueue(encoder.encode(\":\\n\\n\")) }",
+    "              catch { cleanup() }",
+    "            }, HEARTBEAT_MS)",
+    '            req.signal.addEventListener("abort", () => { cleanup() })',
+    "          },",
+    "          cancel() { cleanup() },",
+    "        }),",
+    "        { headers: {",
+    '          "Content-Type": "text/event-stream",',
+    '          "Cache-Control": "no-cache",',
+    '          "Connection": "keep-alive",',
+    "        } },",
+    "      )",
+    "    }",
+    "    return vibes.fetch(req)",
+    "  },",
+    "  websocket: {",
+    "    open(ws) {",
+    "      const client = {",
+    "        readyState: 1,",
+    "        send(data) { try { ws.send(data) } catch {} },",
+    "        ctx: ws.data?.ctx ?? { userId: null },",
+    "      }",
+    "      ws.data.subClient = client",
+    "      addSubClient(client)",
+    "    },",
+    "    message(ws, raw) {",
+    "      const client = ws.data?.subClient",
+    "      if (!client) return",
+    "      const text = typeof raw === \"string\"",
+    "        ? raw",
+    "        : new TextDecoder().decode(raw)",
+    "      void handleSubMessage(client, text)",
+    "    },",
+    "    close(ws) {",
+    "      const client = ws.data?.subClient",
+    "      if (!client) return",
+    "      client.readyState = 3",
+    "      removeSubClient(client)",
+    "    },",
+    "  },",
+    "})",
+    "",
+    "console.log(`[vibes] Production server on :${PORT}`)",
+    "",
+  ].join("\n")
+  fs.writeFileSync(path.join(vibesDir, "server.entry.ts"), entry)
+
+  // ── 4. vite build (client) ────────────────────────────────────────────────
+  log("4/5 vite build (client)")
+  fs.rmSync(distDir, { recursive: true, force: true })
+  run("bunx", ["--bun", "vp", "build"])
+  if (!fs.existsSync(path.join(distDir, "index.html"))) {
+    die("vite build did not produce dist/index.html")
+  }
+
+  // ── 4b. prerender (SSG) — bake the app's root view into dist/index.html ────
+  // So crawlers + first paint see real HTML instead of an empty <div id=root>.
+  // Strictly additive and FAIL-SOFT (see prerender.ts): any failure leaves the
+  // client build untouched, so it can never break a deploy. The client mounts
+  // the full SPA over whatever HTML lands in #root.
+  log("4b/5 prerender (SSG, fail-soft)")
+  await prerenderApp({ root, distDir, vibesDir, log })
+
+  // ── 5. bun build (server) ─────────────────────────────────────────────────
+  log("5/5 bun build server")
+  const serverOut = path.join(vibesDir, "server.mjs")
+  fs.rmSync(serverOut, { force: true })
+  run("bun", [
+    "build",
+    path.join(vibesDir, "server.entry.ts"),
+    "--target=bun",
+    "--outfile",
+    serverOut,
+    // bun:sqlite is a runtime built-in, not a real npm package — must be external.
+    "--external",
+    "bun:sqlite",
+  ])
+  if (!fs.existsSync(serverOut)) die("bun build did not produce .vibes/server.mjs")
+
+  // ── manifest ──────────────────────────────────────────────────────────────
+  // Artifacts are the stateless code; data.db is runtime state owned by the
+  // runtime sandbox and is NOT shipped by the builder.
+  //
+  // hasDb: does this deploy actually need a sqlite DB + litestream wiring?
+  // We load the user's schema and check for non-empty collections. Runtimes
+  // with hasDb=false skip litestream entirely — faster cold-start, no empty
+  // replicas in Tigris. Default to true on any load/parse failure so we don't
+  // silently orphan data on an unexpected schema shape.
+  let hasDb = true
+  try {
+    const schemaModule = (await import(schemaPath)) as { default?: { collections?: Record<string, unknown> } }
+    const collections = schemaModule.default?.collections
+    hasDb = !!collections && Object.keys(collections).length > 0
+  } catch (err) {
+    log(`warn: could not load schema to determine hasDb, defaulting to true: ${(err as Error).message}`)
+  }
+
+  // A "static" deploy serves dist/ directly from object storage; the
+  // orchestrator skips the runtime VM entirely. Three signals must agree:
+  // empty schema, no functions discovered, and the user did not opt out
+  // (no opt-out wired yet — derived purely from build inputs). The
+  // orchestrator re-checks all three server-side, so a stale flag never
+  // causes data loss.
+  // Workflows force a runtime VM: a static deploy has no server for the
+  // engine to invoke, so workflow-only apps are NOT static.
+  const isStatic = !hasDb && routes.length === 0 && workflows.length === 0
+
+  // Serialize the app's @omg-dev/billing declaration (if any) into the manifest.
+  // The orchestrator reads manifest.catalog at deploy time and persists it to
+  // deploys.catalog_json — the per-version contract the Go enforcer parses for
+  // default-plan / overage / lifecycle-grant decisions. No billing → omitted,
+  // so the enforcer keeps its conservative no-catalog default. An invalid
+  // declaration throws here and fails the build (fail-loud).
+  const billing = await scanBilling(root)
+  if (billing) {
+    log(`billing: catalog from ${path.relative(root, billing.module)}#${billing.exportName}`)
+  }
+
+  const manifest = {
+    version: 1,
+    hasDb,
+    static: isStatic,
+    functions: routes.length,
+    artifacts: [
+      { src: "dist", kind: "dir" },
+      { src: ".vibes/server.mjs", kind: "file" },
+    ],
+    entry: ".vibes/server.mjs",
+    port: 3000,
+    // Workflow names declared by this build. The orchestrator registers a
+    // Restate deployment for the version iff this is non-empty (see
+    // apps/infra/WORKFLOWS.md). Omitted when the app declares none.
+    ...(workflows.length > 0 ? { workflows: workflows.map(w => w.name) } : {}),
+    // Canonical catalog JSON string (deploys.catalog_json contract). Omitted
+    // when the app declares no billing.
+    ...(billing ? { catalog: billing.catalogJson } : {}),
+  }
+  fs.writeFileSync(path.join(vibesDir, "artifacts.json"), JSON.stringify(manifest, null, 2))
+  log(`manifest: hasDb=${hasDb} static=${isStatic} functions=${routes.length} workflows=${workflows.length} billing=${!!billing}`)
+
+  log(`done. artifacts listed in .vibes/artifacts.json`)
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function relFromVibes(absPath: string): string {
+  // server.entry.ts lives at <root>/.vibes/, so imports go up one directory.
+  const r = path.relative(vibesDir, absPath)
+  return r.startsWith(".") ? r : `./${r}`
+}
+
+function run(cmd: string, args: string[]) {
+  const res = spawnSync(cmd, args, { stdio: "inherit", cwd: root })
+  if (res.status !== 0) die(`${cmd} ${args.join(" ")} exited with ${res.status}`)
+}
+
+main().catch(err => {
+  console.error("[vibes-build] unhandled:", err)
+  process.exit(1)
+})

package/src/codegen.ts

@@ -0,0 +1,134 @@
+import fs from "node:fs"
+import path from "node:path"
+import { schemaToZod, schemaToCollections, schemaToDrizzle, type Schema } from "@omg-dev/schema"
+import { scanFunctions } from "./scanner.ts"
+import { scanTriggers } from "./scanner-triggers.ts"
+import { scanWorkflows } from "./scanner-workflows.ts"
+
+// ── generateAll ───────────────────────────────────────────────────────────────
+
+export async function generateAll(root: string): Promise<void> {
+  await regenerateSchema(root)
+  await regenerateRoutes(root)
+  await regenerateTriggers(root)
+  await regenerateWorkflows(root)
+}
+
+// ── regenerateSchema ──────────────────────────────────────────────────────────
+
+/**
+ * Reads schema.ts from root, imports it dynamically, and writes:
+ *   src/db.generated.ts  — TypeScript types + Zod schemas + collection configs
+ *   src/db.drizzle.ts    — Drizzle table definitions for server-side helpers
+ */
+export async function regenerateSchema(root: string): Promise<void> {
+  const schemaPath = path.join(root, "schema.ts")
+  if (!fs.existsSync(schemaPath)) {
+    console.warn(`[vibes:codegen] No schema.ts found at ${schemaPath}`)
+    return
+  }
+
+  let schema: Schema
+  try {
+    // Dynamic import — works because we run in Bun/vite-node context
+    const mod = (await import(schemaPath)) as { default: Schema }
+    schema = mod.default
+  } catch (err) {
+    console.error(`[vibes:codegen] Failed to import schema.ts:`, err)
+    return
+  }
+
+  const srcDir = path.join(root, "src")
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true })
+  }
+
+  const outputPath = path.join(srcDir, "db.generated.ts")
+
+  const lines: string[] = [
+    "// This file is auto-generated by @omg-dev/vite-plugin. Do not edit manually.",
+    "// To regenerate: restart the dev server or run `vp build`.",
+    "",
+    "// ── Zod schemas & types ─────────────────────────────────────────────────────────",
+    "",
+    schemaToZod(schema),
+    "",
+    "// ── Collection configs ─────────────────────────────────────────────────────────",
+    "",
+    schemaToCollections(schema),
+  ]
+
+  fs.writeFileSync(outputPath, lines.join("\n"), "utf-8")
+  console.log(`[vibes:codegen] Generated ${outputPath}`)
+
+  const drizzlePath = path.join(srcDir, "db.drizzle.ts")
+  const drizzleLines = [
+    "// This file is auto-generated by @omg-dev/vite-plugin. Do not edit manually.",
+    "// To regenerate: restart the dev server or run `vp build`.",
+    "",
+    schemaToDrizzle(schema),
+  ]
+
+  fs.writeFileSync(drizzlePath, drizzleLines.join("\n"), "utf-8")
+  console.log(`[vibes:codegen] Generated ${drizzlePath}`)
+}
+
+// ── regenerateRoutes ──────────────────────────────────────────────────────────
+
+/**
+ * Scans functions/ directory and writes .vibes/routes.json
+ */
+export async function regenerateRoutes(root: string): Promise<void> {
+  const routes = await scanFunctions(root)
+
+  const vibesDir = path.join(root, ".vibes")
+  if (!fs.existsSync(vibesDir)) {
+    fs.mkdirSync(vibesDir, { recursive: true })
+  }
+
+  const routesPath = path.join(vibesDir, "routes.json")
+  fs.writeFileSync(routesPath, JSON.stringify(routes, null, 2), "utf-8")
+  console.log(`[vibes:codegen] Generated ${routesPath} with ${routes.length} route(s)`)
+}
+
+// ── regenerateTriggers ────────────────────────────────────────────────────────
+
+/**
+ * Scans functions/ for `cron()` and `on()` calls and writes .vibes/triggers.json
+ * consumed by @omg-dev/server's scheduler (dev) and by the orchestrator's queue
+ * runtime (prod). Throws TriggerScanError on malformed declarations so the
+ * user sees the failure at build / HMR time rather than silently losing a
+ * trigger.
+ */
+export async function regenerateTriggers(root: string): Promise<void> {
+  const triggers = await scanTriggers(root)
+  const vibesDir = path.join(root, ".vibes")
+  if (!fs.existsSync(vibesDir)) {
+    fs.mkdirSync(vibesDir, { recursive: true })
+  }
+  const triggersPath = path.join(vibesDir, "triggers.json")
+  fs.writeFileSync(triggersPath, JSON.stringify(triggers, null, 2), "utf-8")
+  console.log(`[vibes:codegen] Generated ${triggersPath} with ${triggers.length} trigger(s)`)
+}
+
+// ── regenerateWorkflows ───────────────────────────────────────────────────────
+
+/**
+ * Scans functions/ for `workflow()` declarations and writes
+ * .vibes/workflows.json — consumed by @omg-dev/server's dev engine and the
+ * prod Restate endpoint, and read by the orchestrator at publish to decide
+ * whether to register a workflow deployment. Throws WorkflowScanError on
+ * malformed declarations (non-literal name, duplicate names).
+ */
+export async function regenerateWorkflows(root: string): Promise<void> {
+  const workflows = await scanWorkflows(root)
+  const vibesDir = path.join(root, ".vibes")
+  if (!fs.existsSync(vibesDir)) {
+    fs.mkdirSync(vibesDir, { recursive: true })
+  }
+  const workflowsPath = path.join(vibesDir, "workflows.json")
+  fs.writeFileSync(workflowsPath, JSON.stringify(workflows, null, 2), "utf-8")
+  if (workflows.length > 0) {
+    console.log(`[vibes:codegen] Generated ${workflowsPath} with ${workflows.length} workflow(s)`)
+  }
+}

package/src/error-sink.ts

@@ -0,0 +1,66 @@
+/**
+ * Error sink writer used by the vibes vite plugin in dev mode.
+ *
+ * Both server (Vite logger) and runtime (in-iframe reporter) errors get
+ * appended as JSONL to <root>/.vibes/errors.jsonl. The agent-server
+ * inside the sandbox tails this file between turns and splices new
+ * entries into pi's user message.
+ *
+ * Pure helpers — no plugin/Vite types — so they can be unit-tested.
+ */
+
+import fs from "node:fs"
+import path from "node:path"
+
+export interface ErrorSinkEntry {
+  kind: "server" | "runtime"
+  source: string
+  message: string
+  stack?: string
+  file?: unknown
+  line?: unknown
+  col?: unknown
+  viaConsole?: unknown
+  rejection?: unknown
+}
+
+const MAX_BYTES_BEFORE_ROTATE = 1_048_576 // 1 MB
+
+export function errorsPathFor(root: string): string {
+  return path.join(root, ".vibes", "errors.jsonl")
+}
+
+/**
+ * Append one entry to the sink. The `at` timestamp is stamped here so
+ * the file is the authoritative ordering — callers must not pre-stamp.
+ *
+ * Errors are logged but not rethrown — the dev server must keep running
+ * even if the sink is broken. The previous version swallowed silently,
+ * which made a failing writer indistinguishable from "no errors yet".
+ */
+export function appendErrorEntry(
+  errorsPath: string,
+  entry: ErrorSinkEntry,
+): void {
+  try {
+    fs.mkdirSync(path.dirname(errorsPath), { recursive: true })
+    const line = JSON.stringify({ at: Date.now(), ...entry }) + "\n"
+    fs.appendFileSync(errorsPath, line)
+    const stat = fs.statSync(errorsPath)
+    if (stat.size > MAX_BYTES_BEFORE_ROTATE) {
+      fs.renameSync(errorsPath, errorsPath + ".1")
+    }
+  } catch (err) {
+    // Surface the failure to stderr so a missing-file mystery is
+    // diagnosable from /tmp/agent-server.log or the dev process log.
+    console.error(
+      `[vibes:error-sink] failed to append to ${errorsPath}:`,
+      err instanceof Error ? err.message : err,
+    )
+  }
+}
+
+/** Drop ANSI color codes from Vite's rendered logger output. */
+export function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[0-9;]*m/g, "")
+}