robodev 0.32.0 → 0.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robodev",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "CLI for Robodev Starbase — create, auth, link, deploy, and run a project locally with robodev dev",
   "type": "module",
   "license": "MIT",

package/src/dev-clients.ts

@@ -1,5 +1,6 @@
 import type { RouteClients } from "@robodev-ai/runtime";
 import type { EmailClient, JobEnqueueInput, LlmClient } from "@robodev-ai/sdk";
+import type { DevInspectStore } from "./dev-inspect.js";
 
 /**
  * The `ctx.*` clients `robodev dev` can offer offline. `email` prints to the terminal;
@@ -14,13 +15,21 @@ function unavailable(feature: string): never {
   );
 }
 
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 /** Prints mail to stdout so local signup and reset flows are followable. */
-export function consoleEmailClient(log: (line: string) => void): EmailClient {
+export function consoleEmailClient(
+  log: (line: string) => void,
+  inspect: DevInspectStore,
+): EmailClient {
   return {
     async send(input) {
       const to = Array.isArray(input.to) ? input.to.join(", ") : input.to;
       log(`email → ${to}: ${input.subject}`);
       if (input.text) log(`  ${input.text}`);
+      inspect.record({ kind: "email", to, subject: input.subject, text: input.text });
       return { id: `local_${Date.now().toString(36)}`, status: "sent" };
     },
   };
@@ -37,9 +46,10 @@ export function devRouteClients(input: {
   env: Record<string, string>;
   log: (line: string) => void;
   enqueue: (job: JobEnqueueInput) => Promise<{ id: string }>;
+  inspect: DevInspectStore;
 }): RouteClients {
   return {
-    email: consoleEmailClient(input.log),
+    email: consoleEmailClient(input.log, input.inspect),
     llm: offlineLlmClient(),
     agent: {
       createSession: () => unavailable("agent"),
@@ -56,7 +66,28 @@ export function devRouteClients(input: {
       list: () => unavailable("storage"),
     },
     push: { send: () => unavailable("push") },
-    jobs: { enqueue: input.enqueue },
+    jobs: {
+      enqueue: async (job) => {
+        try {
+          const result = await input.enqueue(job);
+          input.inspect.record({
+            kind: "job",
+            name: job.name,
+            payload: job.payload,
+            error: "",
+          });
+          return result;
+        } catch (error) {
+          input.inspect.record({
+            kind: "job",
+            name: job.name,
+            payload: job.payload,
+            error: errorMessage(error),
+          });
+          throw error;
+        }
+      },
+    },
     sockets: {
       send: () => unavailable("sockets"),
       broadcast: () => unavailable("sockets"),

package/src/dev-inspect.test.ts

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  createDevInspect,
+  inspectHtml,
+  isInspectPath,
+  type DevInspectAuthCodeEvent,
+  type DevInspectEmailEvent,
+  type DevInspectJobEvent,
+  type DevInspectLogEvent,
+  type DevInspectRequestEvent,
+} from "./dev-inspect.js";
+
+test("isInspectPath excludes only inspect self-routes", () => {
+  assert.equal(isInspectPath("/_robodev"), true);
+  assert.equal(isInspectPath("/_robodev/logs"), true);
+  assert.equal(isInspectPath("/_robodev/logs.json"), true);
+  assert.equal(isInspectPath("/_robodev/docs"), false);
+  assert.equal(isInspectPath("/_robodev/ready"), false);
+  assert.equal(isInspectPath("/_robodev/scalar"), false);
+  assert.equal(isInspectPath("/openapi.json"), false);
+  assert.equal(isInspectPath("/api/planets"), false);
+});
+
+test("ring buffer drops oldest events past max", () => {
+  const inspect = createDevInspect({ max: 3 });
+  inspect.record({ kind: "log", message: "a" });
+  inspect.record({ kind: "log", message: "b" });
+  inspect.record({ kind: "log", message: "c" });
+  inspect.record({ kind: "log", message: "d" });
+
+  const list = inspect.list();
+  assert.equal(list.length, 3);
+  assert.deepEqual(
+    list.map((event) => (event.kind === "log" ? event.message : "")),
+    ["b", "c", "d"],
+  );
+});
+
+test("list is newest last and does not leak the internal buffer", () => {
+  const inspect = createDevInspect({ max: 500 });
+  inspect.record({ kind: "log", message: "first" });
+  inspect.record({ kind: "log", message: "second" });
+
+  const snapshot = inspect.list();
+  snapshot.pop();
+  assert.equal(inspect.list().length, 2);
+  assert.equal((inspect.list()[1] as DevInspectLogEvent).message, "second");
+});
+
+test("record assigns id, at, and the expected fields for each kind", () => {
+  const inspect = createDevInspect();
+  const before = Date.now();
+
+  const request = inspect.record({
+    kind: "request",
+    method: "GET",
+    path: "/api/planets",
+    status: 200,
+    durationMs: 12,
+  }) as DevInspectRequestEvent;
+  const email = inspect.record({
+    kind: "email",
+    to: "a@b.test",
+    subject: "Hello",
+    text: "Body",
+  }) as DevInspectEmailEvent;
+  const auth = inspect.record({
+    kind: "auth_code",
+    type: "magic",
+    to: "a@b.test",
+    code: "123456",
+  }) as DevInspectAuthCodeEvent;
+  const job = inspect.record({
+    kind: "job",
+    name: "hourly",
+    payload: { n: 1 },
+    error: "",
+  }) as DevInspectJobEvent;
+  const log = inspect.record({ kind: "log", message: "Change detected, reloading…" });
+
+  const after = Date.now();
+  for (const event of [request, email, auth, job, log]) {
+    assert.ok(event.id);
+    assert.ok(event.at >= before && event.at <= after);
+  }
+
+  assert.equal(request.kind, "request");
+  assert.equal(request.method, "GET");
+  assert.equal(request.path, "/api/planets");
+  assert.equal(request.status, 200);
+  assert.equal(request.durationMs, 12);
+
+  assert.equal(email.kind, "email");
+  assert.equal(email.to, "a@b.test");
+  assert.equal(email.subject, "Hello");
+  assert.equal(email.text, "Body");
+
+  assert.equal(auth.kind, "auth_code");
+  assert.equal(auth.type, "magic");
+  assert.equal(auth.to, "a@b.test");
+  assert.equal(auth.code, "123456");
+
+  assert.equal(job.kind, "job");
+  assert.equal(job.name, "hourly");
+  assert.deepEqual(job.payload, { n: 1 });
+  assert.equal(job.error, "");
+
+  assert.equal(log.kind, "log");
+  assert.equal((log as DevInspectLogEvent).message, "Change detected, reloading…");
+
+  assert.equal(inspect.list().length, 5);
+});
+
+test("inspect HTML has four lists and polls logs.json", () => {
+  const html = inspectHtml();
+  assert.match(html, /<h2>Requests<\/h2>/);
+  assert.match(html, /<h2>Emails<\/h2>/);
+  assert.match(html, /<h2>Jobs<\/h2>/);
+  assert.match(html, /<h2>Logs<\/h2>/);
+  assert.match(html, /\/_robodev\/logs\.json/);
+  assert.match(html, /setInterval\(poll, 1000\)/);
+});

package/src/dev-inspect.ts

@@ -0,0 +1,230 @@
+export const DEV_INSPECT_MAX = 500;
+
+const INSPECT_PATHS = new Set(["/_robodev", "/_robodev/logs", "/_robodev/logs.json"]);
+
+export type DevInspectKind = "request" | "email" | "auth_code" | "job" | "log";
+
+type EventBase = {
+  id: string;
+  at: number;
+};
+
+export type DevInspectRequestEvent = EventBase & {
+  kind: "request";
+  method: string;
+  path: string;
+  status: number;
+  durationMs: number;
+};
+
+export type DevInspectEmailEvent = EventBase & {
+  kind: "email";
+  to: string;
+  subject: string;
+  text?: string;
+};
+
+export type DevInspectAuthCodeEvent = EventBase & {
+  kind: "auth_code";
+  type: string;
+  to: string;
+  code: string;
+};
+
+export type DevInspectJobEvent = EventBase & {
+  kind: "job";
+  name: string;
+  payload: unknown;
+  error: string;
+};
+
+export type DevInspectLogEvent = EventBase & {
+  kind: "log";
+  message: string;
+};
+
+export type DevInspectEvent =
+  | DevInspectRequestEvent
+  | DevInspectEmailEvent
+  | DevInspectAuthCodeEvent
+  | DevInspectJobEvent
+  | DevInspectLogEvent;
+
+export type DevInspectRecordInput =
+  | Omit<DevInspectRequestEvent, "id" | "at">
+  | Omit<DevInspectEmailEvent, "id" | "at">
+  | Omit<DevInspectAuthCodeEvent, "id" | "at">
+  | Omit<DevInspectJobEvent, "id" | "at">
+  | Omit<DevInspectLogEvent, "id" | "at">;
+
+export type DevInspectStore = {
+  record: (input: DevInspectRecordInput) => DevInspectEvent;
+  list: () => DevInspectEvent[];
+  html: () => string;
+};
+
+/** Inspect HTML/JSON self-routes — do not print or record these as requests. */
+export function isInspectPath(pathname: string): boolean {
+  return INSPECT_PATHS.has(pathname);
+}
+
+export function createDevInspect(options?: { max?: number }): DevInspectStore {
+  const max = options?.max ?? DEV_INSPECT_MAX;
+  const events: DevInspectEvent[] = [];
+  let nextId = 1;
+
+  function record(input: DevInspectRecordInput): DevInspectEvent {
+    const event = { ...input, id: String(nextId++), at: Date.now() } as DevInspectEvent;
+    events.push(event);
+    if (events.length > max) {
+      events.splice(0, events.length - max);
+    }
+    return event;
+  }
+
+  function list(): DevInspectEvent[] {
+    return events.slice();
+  }
+
+  return { record, list, html: inspectHtml };
+}
+
+/** Inline inspect page — same pattern as runtime `swaggerHtml` (string template, no FE build). */
+export function inspectHtml(): string {
+  return `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Robodev Inspect</title>
+    <style>
+      :root { color-scheme: light dark; }
+      body {
+        margin: 0 auto;
+        max-width: 960px;
+        padding: 24px 20px 48px;
+        font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+        line-height: 1.45;
+      }
+      h1 { font-size: 1.25rem; font-weight: 650; margin: 0 0 4px; }
+      .lead { color: #666; margin: 0 0 24px; font-size: 0.9rem; }
+      h2 {
+        font-size: 0.75rem;
+        font-weight: 700;
+        letter-spacing: 0.06em;
+        text-transform: uppercase;
+        margin: 28px 0 8px;
+      }
+      ul { list-style: none; margin: 0; padding: 0; border-top: 1px solid #ddd; }
+      li {
+        font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+        font-size: 12.5px;
+        padding: 8px 0;
+        border-bottom: 1px solid #eee;
+        white-space: pre-wrap;
+        word-break: break-word;
+      }
+      .empty { color: #888; font-family: inherit; }
+      .meta { color: #888; }
+      @media (prefers-color-scheme: dark) {
+        .lead, .empty, .meta { color: #9aa0a6; }
+        ul { border-top-color: #333; }
+        li { border-bottom-color: #2a2a2a; }
+      }
+    </style>
+  </head>
+  <body>
+    <h1>Inspect</h1>
+    <p class="lead">Local <code>robodev dev</code> events. Newest first. Polls every 1s.</p>
+    <h2>Requests</h2>
+    <ul id="requests"></ul>
+    <h2>Emails</h2>
+    <ul id="emails"></ul>
+    <h2>Jobs</h2>
+    <ul id="jobs"></ul>
+    <h2>Logs</h2>
+    <ul id="logs"></ul>
+    <script>
+      function timeLabel(at) {
+        return new Date(at).toLocaleTimeString();
+      }
+      function emptyRow() {
+        const li = document.createElement("li");
+        li.className = "empty";
+        li.textContent = "None yet";
+        return li;
+      }
+      function line(at, text) {
+        const li = document.createElement("li");
+        const meta = document.createElement("span");
+        meta.className = "meta";
+        meta.textContent = timeLabel(at) + "  ";
+        li.appendChild(meta);
+        li.appendChild(document.createTextNode(text));
+        return li;
+      }
+      function fill(id, rows) {
+        const ul = document.getElementById(id);
+        ul.replaceChildren();
+        if (rows.length === 0) {
+          ul.appendChild(emptyRow());
+          return;
+        }
+        for (const row of rows) ul.appendChild(row);
+      }
+      function payloadText(payload) {
+        if (payload === undefined) return "";
+        try {
+          return " " + JSON.stringify(payload);
+        } catch {
+          return " [unserializable payload]";
+        }
+      }
+      function render(events) {
+        const newest = events.slice().reverse();
+        fill(
+          "requests",
+          newest
+            .filter((e) => e.kind === "request")
+            .map((e) => line(e.at, e.method + " " + e.path + " " + e.status + " " + e.durationMs + "ms")),
+        );
+        fill(
+          "emails",
+          newest
+            .filter((e) => e.kind === "email" || e.kind === "auth_code")
+            .map((e) => {
+              if (e.kind === "auth_code") {
+                return line(e.at, e.type + "  " + e.to + "  " + e.code);
+              }
+              const extra = e.text ? "\\n" + e.text : "";
+              return line(e.at, e.to + "  " + e.subject + extra);
+            }),
+        );
+        fill(
+          "jobs",
+          newest
+            .filter((e) => e.kind === "job")
+            .map((e) => {
+              const err = e.error ? "  " + e.error : "";
+              return line(e.at, e.name + payloadText(e.payload) + err);
+            }),
+        );
+        fill(
+          "logs",
+          newest.filter((e) => e.kind === "log").map((e) => line(e.at, e.message)),
+        );
+      }
+      async function poll() {
+        try {
+          const events = await fetch("/_robodev/logs.json").then((r) => r.json());
+          render(events);
+        } catch {
+          /* keep last render */
+        }
+      }
+      poll();
+      setInterval(poll, 1000);
+    </script>
+  </body>
+</html>`;
+}

package/src/dev-server.ts

@@ -16,6 +16,7 @@ import {
 import type { JobEnqueueInput, RobodevDb } from "@robodev-ai/sdk";
 import type { RuntimeJob } from "@robodev-ai/runtime";
 import { devRouteClients } from "./dev-clients.js";
+import { isInspectPath, type DevInspectStore } from "./dev-inspect.js";
 
 /** One compiled generation of the project. Swapped wholesale on reload. */
 export type DevRuntime = {
@@ -33,6 +34,7 @@ export type DevServerOptions = {
   env: Record<string, string>;
   log: (line: string) => void;
   enqueue: (job: JobEnqueueInput) => Promise<{ id: string }>;
+  inspect: DevInspectStore;
 };
 
 const SWAGGER_PATHS = new Set(["/_robodev/docs", "/_robodev/swagger", "/docs", "/swagger"]);
@@ -52,9 +54,10 @@ function rawBodyOf(request: FastifyRequest): Buffer | undefined {
 }
 
 /**
- * A single-project HTTP host. Unlike the hosted project host there is no `Host` lookup,
- * no static SPA serving (local Vite does that), and no request logging — the routes,
- * validation, and OpenAPI all come from `@robodev-ai/runtime`.
+ * A single-project HTTP host. Unlike the hosted project host there is no `Host` lookup
+ * and no static SPA serving (local Vite does that). Fastify stays `logger: false`;
+ * project/auth/docs requests are recorded on the process-local inspect page after reply.
+ * Routes, validation, and OpenAPI all come from `@robodev-ai/runtime`.
  */
 export async function startDevServer(
   options: DevServerOptions,
@@ -112,92 +115,138 @@ export async function startDevServer(
     const pathname = pathnameOf(request.url);
     const method = request.method.toLowerCase();
 
-    if (pathname === "/_robodev/ready") {
-      const runtime = getRuntime();
-      if (!runtime) return reply.code(503).send({ error: "not_ready" });
-      try {
-        await runtime.pool.query("SELECT 1");
-        return reply.send({ ok: true });
-      } catch {
-        return reply.code(503).send({ error: "not_ready" });
+    if (isInspectPath(pathname)) {
+      if (pathname === "/_robodev/logs.json") {
+        return reply.send(options.inspect.list());
       }
+      return reply.type("text/html; charset=utf-8").send(options.inspect.html());
     }
 
-    if (SWAGGER_PATHS.has(pathname)) {
-      return reply.type("text/html; charset=utf-8").send(swaggerHtml("/openapi.json"));
-    }
-    if (SCALAR_PATHS.has(pathname)) {
-      return reply.type("text/html; charset=utf-8").send(scalarHtml("/openapi.json"));
-    }
-
-    const runtime = getRuntime();
-    if (!runtime) {
-      return reply.code(503).send({
-        error: "not_ready",
-        message: "The project is still compiling. Retry in a moment.",
+    const started = Date.now();
+    try {
+      await dispatchDevRequest();
+    } finally {
+      const status = reply.statusCode;
+      const durationMs = Date.now() - started;
+      options.inspect.record({
+        kind: "request",
+        method: request.method,
+        path: pathname,
+        status,
+        durationMs,
       });
+      // Print here (not via `log`) so request lines stay off the Inspect Logs list.
+      console.log(`${request.method} ${pathname} ${status} ${durationMs}ms`);
     }
+    return reply;
+
+    async function dispatchDevRequest(): Promise<void> {
+      if (pathname === "/_robodev/ready") {
+        const runtime = getRuntime();
+        if (!runtime) {
+          await reply.code(503).send({ error: "not_ready" });
+          return;
+        }
+        try {
+          await runtime.pool.query("SELECT 1");
+          await reply.send({ ok: true });
+        } catch {
+          await reply.code(503).send({ error: "not_ready" });
+        }
+        return;
+      }
 
-    if (pathname === "/openapi.json") {
-      return reply.send(runtime.openapi);
-    }
+      if (SWAGGER_PATHS.has(pathname)) {
+        await reply.type("text/html; charset=utf-8").send(swaggerHtml("/openapi.json"));
+        return;
+      }
+      if (SCALAR_PATHS.has(pathname)) {
+        await reply.type("text/html; charset=utf-8").send(scalarHtml("/openapi.json"));
+        return;
+      }
 
-    if (isLocalAuthPath(pathname)) {
-      const result = await handleLocalAuth(
-        {
-          method: request.method,
-          pathname,
-          body: request.body,
-          query: request.query,
-          authorization: request.headers.authorization,
-        },
-        {
-          db: runtime.pool,
-          projectId: options.projectId,
-          jwtSecret: options.jwtSecret,
-          deliverCode: ({ to, type, code }) => options.log(`${type} code for ${to}: ${code}`),
-        },
-      );
-      return reply.code(result.status).send(result.body);
-    }
+      const runtime = getRuntime();
+      if (!runtime) {
+        await reply.code(503).send({
+          error: "not_ready",
+          message: "The project is still compiling. Retry in a moment.",
+        });
+        return;
+      }
+
+      if (pathname === "/openapi.json") {
+        await reply.send(runtime.openapi);
+        return;
+      }
 
-    if (!matchProjectRoute(pathname, method, runtime.routes)) {
-      return reply.code(404).send({
-        error: "not_found",
-        message: `${request.method} ${pathname} is not defined`,
-        routes: runtime.routes.map((route) => `${route.method.toUpperCase()} ${route.path}`),
+      if (isLocalAuthPath(pathname)) {
+        const result = await handleLocalAuth(
+          {
+            method: request.method,
+            pathname,
+            body: request.body,
+            query: request.query,
+            authorization: request.headers.authorization,
+          },
+          {
+            db: runtime.pool,
+            projectId: options.projectId,
+            jwtSecret: options.jwtSecret,
+            deliverCode: ({ to, type, code }) => {
+              options.inspect.record({ kind: "auth_code", type, to, code });
+              options.log(`${type} code for ${to}: ${code}`);
+            },
+          },
+        );
+        await reply.code(result.status).send(result.body);
+        return;
+      }
+
+      if (!matchProjectRoute(pathname, method, runtime.routes)) {
+        await reply.code(404).send({
+          error: "not_found",
+          message: `${request.method} ${pathname} is not defined`,
+          routes: runtime.routes.map((route) => `${route.method.toUpperCase()} ${route.path}`),
+        });
+        return;
+      }
+
+      const outcome = await runRoute({
+        db: runtime.db,
+        routes: runtime.routes,
+        method,
+        pathname,
+        query: request.query ?? {},
+        body: request.body,
+        rawBody: rawBodyOf(request),
+        headers: request.headers as Record<string, string | string[] | undefined>,
+        authorization: request.headers.authorization,
+        resolveUser: (authorization) =>
+          resolveLocalUser(
+            { projectId: options.projectId, jwtSecret: options.jwtSecret },
+            authorization,
+          ),
+        clients: () =>
+          devRouteClients({
+            env: options.env,
+            log: options.log,
+            enqueue: options.enqueue,
+            inspect: options.inspect,
+          }),
       });
-    }
 
-    const outcome = await runRoute({
-      db: runtime.db,
-      routes: runtime.routes,
-      method,
-      pathname,
-      query: request.query ?? {},
-      body: request.body,
-      rawBody: rawBodyOf(request),
-      headers: request.headers as Record<string, string | string[] | undefined>,
-      authorization: request.headers.authorization,
-      resolveUser: (authorization) =>
-        resolveLocalUser(
-          { projectId: options.projectId, jwtSecret: options.jwtSecret },
-          authorization,
-        ),
-      clients: () =>
-        devRouteClients({ env: options.env, log: options.log, enqueue: options.enqueue }),
-    });
-
-    if (outcome.kind === "error") {
-      return reply.code(outcome.status).send(outcome.body);
-    }
-    for (const [name, value] of Object.entries(outcome.encoded.headers)) {
-      reply.header(name, value);
+      if (outcome.kind === "error") {
+        await reply.code(outcome.status).send(outcome.body);
+        return;
+      }
+      for (const [name, value] of Object.entries(outcome.encoded.headers)) {
+        reply.header(name, value);
+      }
+      await reply
+        .code(outcome.encoded.status)
+        .type(outcome.encoded.contentType)
+        .send(outcome.encoded.payload);
     }
-    return reply
-      .code(outcome.encoded.status)
-      .type(outcome.encoded.contentType)
-      .send(outcome.encoded.payload);
   });
 
   await app.listen({ port: options.port, host: "0.0.0.0" });

package/src/dev.ts

@@ -30,6 +30,7 @@ import {
 } from "./dev-project.js";
 import { externalDevPostgres, startDevPostgres, type DevPostgres } from "./dev-postgres.js";
 import { devRouteClients } from "./dev-clients.js";
+import { createDevInspect } from "./dev-inspect.js";
 import { buildDevOpenApi, startDevServer, type DevRuntime } from "./dev-server.js";
 
 export type DevArgs = {
@@ -127,10 +128,10 @@ async function resolveCreateDb(backendDir: string, root: string): Promise<typeof
   return fallbackCreateDb;
 }
 
-function printPlan(plan: SchemaPlan): void {
+function printPlan(plan: SchemaPlan, log: (line: string) => void): void {
   for (const op of plan.operations) {
     const mark = op.destructive ? "!" : " ";
-    console.log(` ${mark} ${op.type} ${op.table}${op.column ? `.${op.column}` : ""}`);
+    log(` ${mark} ${op.type} ${op.table}${op.column ? `.${op.column}` : ""}`);
   }
 }
 
@@ -157,7 +158,11 @@ export async function main(args: string[]): Promise<void> {
   let lastSchemaSource = "";
   let closing = false;
 
-  const log = (line: string) => console.log(line);
+  const inspect = createDevInspect({ max: 500 });
+  const log = (line: string) => {
+    console.log(line);
+    inspect.record({ kind: "log", message: line });
+  };
   const engine = createLocalJobsEngine({
     query: (sql, values) => {
       if (!current) throw new Error("jobs engine not ready");
@@ -165,7 +170,8 @@ export async function main(args: string[]): Promise<void> {
     },
     getGeneration: () => current,
     log,
-    clients: () => devRouteClients({ env, log, enqueue: (input) => engine.enqueue(input) }),
+    clients: () =>
+      devRouteClients({ env, log, inspect, enqueue: (input) => engine.enqueue(input) }),
   });
 
   async function compileAndActivate(input: { syncSchema: boolean }): Promise<void> {
@@ -199,12 +205,12 @@ export async function main(args: string[]): Promise<void> {
     if (input.syncSchema || schemaSource !== lastSchemaSource) {
       const plan = await buildPlan(postgres.connectionString, loaded.database);
       if (plan.destructive && !parsed.force) {
-        console.log("Destructive schema changes (skipped, rerun with --force):");
-        printPlan(plan);
+        log("Destructive schema changes (skipped, rerun with --force):");
+        printPlan(plan, log);
       } else {
         if (plan.operations.length > 0) {
-          console.log("Schema changes:");
-          printPlan(plan);
+          log("Schema changes:");
+          printPlan(plan, log);
         }
         await applyPlan(postgres.connectionString, plan);
         lastSchemaSource = schemaSource;
@@ -227,17 +233,17 @@ export async function main(args: string[]): Promise<void> {
     await engine.reconcile(loaded.jobs);
 
     for (const route of loaded.routes) {
-      console.log(`  ${route.method.toUpperCase()} ${route.path}`);
+      log(`  ${route.method.toUpperCase()} ${route.path}`);
     }
     for (const job of loaded.jobs) {
       if (job.def.cron) {
-        console.log(`  job ${job.name} (cron ${job.def.cron})`);
+        log(`  job ${job.name} (cron ${job.def.cron})`);
       } else {
-        console.log(`  job ${job.name}`);
+        log(`  job ${job.name}`);
       }
     }
     if (loaded.sockets.length > 0) {
-      console.log(
+      log(
         `  ${loaded.sockets.length} socket(s) compiled but not served — sockets need hosted Starbase.`,
       );
     }
@@ -262,6 +268,7 @@ export async function main(args: string[]): Promise<void> {
         jwtSecret: DEV_JWT_SECRET,
         env,
         log,
+        inspect,
         enqueue: (input) => engine.enqueue(input),
       },
       () => current,
@@ -285,6 +292,7 @@ export async function main(args: string[]): Promise<void> {
   }
   console.log(`API       ${apiUrl}`);
   console.log(`Swagger   ${apiUrl}/_robodev/docs`);
+  console.log(`Inspect   ${apiUrl}/_robodev/logs`);
   console.log(
     `Project   ${relative(process.cwd(), project.backendDir) || "."} (${project.layout})`,
   );
@@ -305,7 +313,7 @@ export async function main(args: string[]): Promise<void> {
       }
       running = true;
       try {
-        console.log("Change detected, reloading…");
+        log("Change detected, reloading…");
         await compileAndActivate({ syncSchema: false });
       } catch (error) {
         console.error(error instanceof Error ? error.message : error);

package/templates/auth-chat/package.json

@@ -12,7 +12,7 @@
     "@robodev-ai/sdk": "^0.11.0"
   },
   "devDependencies": {
-    "robodev": "^0.32.0",
+    "robodev": "^0.33.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }

package/templates/backend/package.json

@@ -11,7 +11,7 @@
     "@robodev-ai/sdk": "^0.11.0"
   },
   "devDependencies": {
-    "robodev": "^0.32.0",
+    "robodev": "^0.33.0",
     "typescript": "^5.9.2"
   }
 }

package/templates/empty/package.json

@@ -11,7 +11,7 @@
     "@robodev-ai/sdk": "^0.11.0"
   },
   "devDependencies": {
-    "robodev": "^0.32.0",
+    "robodev": "^0.33.0",
     "typescript": "^5.9.2"
   }
 }

package/templates/marketplace/package.json

@@ -12,7 +12,7 @@
     "@robodev-ai/sdk": "^0.11.0"
   },
   "devDependencies": {
-    "robodev": "^0.32.0",
+    "robodev": "^0.33.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }

package/templates/space/package.json

@@ -12,7 +12,7 @@
     "@robodev-ai/sdk": "^0.11.0"
   },
   "devDependencies": {
-    "robodev": "^0.32.0",
+    "robodev": "^0.33.0",
     "rulesync": "^8.18.0",
     "typescript": "^5.9.2"
   }