robodev 0.35.0 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robodev",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "CLI for Robodev Starbase — create, auth, link, deploy, and run a project locally with robodev dev",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,7 @@
     "embedded-postgres": "17.10.0-beta.17",
     "fastify": "^5.12.1",
     "tsx": "^4.20.5",
-    "@robodev-ai/runtime": "0.4.0",
+    "@robodev-ai/runtime": "0.4.1",
     "@robodev-ai/sdk": "0.11.0"
   },
   "devDependencies": {

package/src/dev-clients.ts

@@ -4,8 +4,18 @@ import {
   type StorageQueryable,
 } from "@robodev-ai/runtime";
 import type { RouteClients } from "@robodev-ai/runtime";
-import type { EmailClient, JobEnqueueInput, LlmClient } from "@robodev-ai/sdk";
-import type { DevInspectStore } from "./dev-inspect.js";
+import type {
+  EmailClient,
+  JobEnqueueInput,
+  LlmClient,
+  SocketsClient,
+  StorageClient,
+} from "@robodev-ai/sdk";
+import {
+  truncateInspectPreview,
+  type DevInspectStore,
+  type StorageInspectOp,
+} from "./dev-inspect.js";
 
 /**
  * The `ctx.*` clients `robodev dev` can offer offline. `email` prints to the terminal;
@@ -21,6 +31,68 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+function inspectStorageClient(client: StorageClient, inspect: DevInspectStore): StorageClient {
+  async function tracked<T>(op: StorageInspectOp, key: string, run: () => Promise<T>): Promise<T> {
+    try {
+      const result = await run();
+      inspect.record({ kind: "storage", op, key, ok: true });
+      return result;
+    } catch (error) {
+      inspect.record({
+        kind: "storage",
+        op,
+        key,
+        ok: false,
+        error: errorMessage(error),
+      });
+      throw error;
+    }
+  }
+  return {
+    upload: (key, data, options) => tracked("upload", key, () => client.upload(key, data, options)),
+    get: (key) => tracked("get", key, () => client.get(key)),
+    getUrl: (key, options) => tracked("getUrl", key, () => client.getUrl(key, options)),
+    delete: (key) => tracked("delete", key, () => client.delete(key)),
+    list: (options) => tracked("list", options?.prefix ?? "", () => client.list(options)),
+  };
+}
+
+function inspectSocketsClient(client: SocketsClient, inspect: DevInspectStore): SocketsClient {
+  function tracked(
+    socketKind: "send" | "broadcast",
+    name: string,
+    payload: unknown,
+    run: () => void,
+  ) {
+    try {
+      run();
+      inspect.record({
+        kind: "socket",
+        socketKind,
+        name,
+        preview: truncateInspectPreview(payload),
+      });
+    } catch (error) {
+      inspect.record({
+        kind: "socket",
+        socketKind,
+        name,
+        error: errorMessage(error),
+        preview: truncateInspectPreview(payload),
+      });
+      throw error;
+    }
+  }
+  return {
+    send(input) {
+      tracked("send", input.name, input.payload, () => client.send(input));
+    },
+    broadcast(input) {
+      tracked("broadcast", input.name, input.payload, () => client.broadcast(input));
+    },
+  };
+}
+
 /** Prints mail to stdout so local signup and reset flows are followable. */
 export function consoleEmailClient(
   log: (line: string) => void,
@@ -65,18 +137,22 @@ export function devRouteClients(input: {
       subscribe: () => notConfigured("llm_not_configured"),
       destroy: () => notConfigured("llm_not_configured"),
     },
-    storage: createLocalStorageClient({
-      query: input.query,
-      objectsDir: input.objectsDir,
-      publicBaseUrl: input.publicBaseUrl,
-      projectId: input.projectId,
-      jwtSecret: input.jwtSecret,
-    }),
+    storage: inspectStorageClient(
+      createLocalStorageClient({
+        query: input.query,
+        objectsDir: input.objectsDir,
+        publicBaseUrl: input.publicBaseUrl,
+        projectId: input.projectId,
+        jwtSecret: input.jwtSecret,
+      }),
+      input.inspect,
+    ),
     push: { send: () => notConfigured("push_not_configured") },
     jobs: {
       enqueue: async (job) => {
         try {
           const result = await input.enqueue(job);
+          // Enqueue is not a run; the dashboard Jobs page reads `job_run` from onJobFinished.
           input.inspect.record({
             kind: "job",
             name: job.name,
@@ -95,7 +171,7 @@ export function devRouteClients(input: {
         }
       },
     },
-    sockets: createProjectSocketsClient(input.projectId),
+    sockets: inspectSocketsClient(createProjectSocketsClient(input.projectId), input.inspect),
     env: input.env,
   };
 }

package/src/dev-inspect.test.ts

@@ -1,9 +1,16 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
 import {
+  buildDashboardState,
+  callMatchesRoute,
   createDevInspect,
   inspectHtml,
+  isHistogramExcludedPath,
   isInspectPath,
+  shouldCountRequestHistogram,
+  socketEventMatchesDef,
+  storageActivityMatchesKey,
+  truncateInspectPreview,
   type DevInspectAuthCodeEvent,
   type DevInspectEmailEvent,
   type DevInspectJobEvent,
@@ -11,9 +18,21 @@ import {
   type DevInspectRequestEvent,
 } from "./dev-inspect.js";
 
-test("isInspectPath excludes only inspect self-routes", () => {
+const fileRuntime = {
+  routes: [{ method: "get", path: "/api/planets" }],
+};
+
+test("isInspectPath covers dashboard pages and JSON only", () => {
   assert.equal(isInspectPath("/_robodev"), true);
+  assert.equal(isInspectPath("/_robodev/apis"), true);
+  assert.equal(isInspectPath("/_robodev/jobs"), true);
+  assert.equal(isInspectPath("/_robodev/emails"), true);
+  assert.equal(isInspectPath("/_robodev/auth"), true);
+  assert.equal(isInspectPath("/_robodev/storage"), true);
+  assert.equal(isInspectPath("/_robodev/sockets"), true);
   assert.equal(isInspectPath("/_robodev/logs"), true);
+  assert.equal(isInspectPath("/storage/objects/avatar.png"), false);
+  assert.equal(isInspectPath("/_robodev/state.json"), true);
   assert.equal(isInspectPath("/_robodev/logs.json"), true);
   assert.equal(isInspectPath("/_robodev/docs"), false);
   assert.equal(isInspectPath("/_robodev/ready"), false);
@@ -22,6 +41,26 @@ test("isInspectPath excludes only inspect self-routes", () => {
   assert.equal(isInspectPath("/api/planets"), false);
 });
 
+test("shouldCountRequestHistogram counts Auth and matched file routes only", () => {
+  assert.equal(shouldCountRequestHistogram("/api/user/me", fileRuntime, "GET"), true);
+  assert.equal(shouldCountRequestHistogram("/api/user/auth/google", fileRuntime, "GET"), true);
+  assert.equal(shouldCountRequestHistogram("/api/planets", fileRuntime, "GET"), true);
+  assert.equal(shouldCountRequestHistogram("/api/planets", fileRuntime, "POST"), false);
+  assert.equal(shouldCountRequestHistogram("/api/unknown", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/_robodev", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/_robodev/apis", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/_robodev/storage", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/_robodev/sockets", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/storage/objects/a.png", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/_robodev/docs", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/_robodev/scalar", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/_robodev/ready", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/openapi.json", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/docs", fileRuntime, "GET"), false);
+  assert.equal(shouldCountRequestHistogram("/swagger", fileRuntime, "GET"), false);
+  assert.equal(isHistogramExcludedPath("/scalar"), true);
+});
+
 test("ring buffer drops oldest events past max", () => {
   const inspect = createDevInspect({ max: 3 });
   inspect.record({ kind: "log", message: "a" });
@@ -37,6 +76,32 @@ test("ring buffer drops oldest events past max", () => {
   );
 });
 
+test("request histogram survives 500-event ring rotation", () => {
+  const inspect = createDevInspect({ max: 2 });
+  inspect.incrementRequestHistogram(200);
+  inspect.incrementRequestHistogram(200);
+  inspect.incrementRequestHistogram(404);
+  inspect.incrementRequestHistogram(500);
+  inspect.record({ kind: "request", method: "GET", path: "/api/a", status: 200, durationMs: 1 });
+  inspect.record({ kind: "request", method: "GET", path: "/api/b", status: 200, durationMs: 1 });
+  inspect.record({ kind: "request", method: "GET", path: "/api/c", status: 200, durationMs: 1 });
+  assert.equal(inspect.list().length, 2);
+
+  const last = inspect.requestHistogram().at(-1);
+  assert.equal(last?.c2xx, 2);
+  assert.equal(last?.c4xx, 1);
+  assert.equal(last?.c5xx, 1);
+});
+
+test("3xx does not increment request histogram buckets", () => {
+  const inspect = createDevInspect();
+  inspect.incrementRequestHistogram(302);
+  const last = inspect.requestHistogram().at(-1);
+  assert.equal(last?.c2xx, 0);
+  assert.equal(last?.c4xx, 0);
+  assert.equal(last?.c5xx, 0);
+});
+
 test("list is newest last and does not leak the internal buffer", () => {
   const inspect = createDevInspect({ max: 500 });
   inspect.record({ kind: "log", message: "first" });
@@ -112,12 +177,209 @@ test("record assigns id, at, and the expected fields for each kind", () => {
   assert.equal(inspect.list().length, 5);
 });
 
-test("inspect HTML has four lists and polls logs.json", () => {
+test("callMatchesRoute uses matchPathParams and requires method", () => {
+  const route = { method: "GET", path: "/api/planets/:id" };
+  assert.equal(callMatchesRoute({ method: "GET", path: "/api/planets/123" }, route), true);
+  assert.equal(callMatchesRoute({ method: "GET", path: "/api/planets" }, route), false);
+  assert.equal(callMatchesRoute({ method: "POST", path: "/api/planets/123" }, route), false);
+});
+
+test("dashboard snapshot lists reserved Auth, filters emails, and ignores enqueue jobs", async () => {
+  const inspect = createDevInspect();
+  inspect.record({
+    kind: "request",
+    method: "GET",
+    path: "/api/planets",
+    status: 200,
+    durationMs: 4,
+  });
+  inspect.record({
+    kind: "request",
+    method: "GET",
+    path: "/_robodev/docs",
+    status: 200,
+    durationMs: 1,
+  });
+  inspect.record({ kind: "email", to: "a@b.test", subject: "Hello", text: "Body" });
+  inspect.record({ kind: "auth_code", type: "magic", to: "a@b.test", code: "999111" });
+  inspect.record({ kind: "job", name: "hourly", payload: { n: 1 }, error: "" });
+  inspect.record({
+    kind: "job_run",
+    name: "hourly",
+    status: "failed",
+    payload: { n: 1 },
+    error: "boom",
+  });
+  inspect.incrementJobHistogram("failed");
+
+  const state = await buildDashboardState({
+    inspect,
+    runtime: {
+      routes: [{ method: "get", path: "/api/planets", file: "api/planets.ts" }],
+      jobs: [{ name: "hourly", file: "jobs/hourly.ts", def: { cron: "0 * * * *" } }],
+    },
+  });
+
+  assert.equal(state.overview.apiCount, 1 + 12);
+  assert.equal(state.overview.jobCount, 1);
+  assert.equal(state.overview.google, "broker");
+  assert.ok(state.routes.some((route) => route.path === "/api/user/auth/google/callback"));
+  assert.equal(state.calls.length, 1);
+  assert.equal(state.calls[0]?.path, "/api/planets");
+  assert.equal(state.emails.length, 1);
+  assert.equal(state.emails[0]?.subject, "Hello");
+  assert.equal(state.jobRuns.length, 1);
+  assert.equal(state.jobRuns[0]?.status, "failed");
+  assert.equal(state.overview.jobHistogram.at(-1)?.failed, 1);
+  assert.deepEqual(state.auth.users, []);
+  assert.equal(state.overview.storageObjectCount, 0);
+  assert.equal(state.overview.socketCount, 0);
+  assert.deepEqual(state.storage, { objects: [], activity: [] });
+  assert.deepEqual(state.sockets, { connected: 0, defs: [], events: [] });
+});
+
+test("incomplete Google credentials are not labeled override", async () => {
+  const state = await buildDashboardState({
+    inspect: createDevInspect(),
+    runtime: { routes: [], jobs: [] },
+    googleClientId: "only-id",
+  });
+  assert.equal(state.overview.google, "incomplete");
+  assert.equal(state.auth.google, "incomplete");
+});
+
+test("inspect HTML has nav labels and polls state.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, />Overview</);
+  assert.match(html, />APIs</);
+  assert.match(html, />Jobs</);
+  assert.match(html, />Emails</);
+  assert.match(html, />Auth</);
+  assert.match(html, />Storage</);
+  assert.match(html, />Sockets</);
+  assert.match(html, /\/_robodev\/storage/);
+  assert.match(html, /\/_robodev\/sockets/);
+  assert.doesNotMatch(html, /<h2>Requests<\/h2>/);
+  assert.doesNotMatch(html, /<h2>Emails<\/h2>/);
+  assert.doesNotMatch(html, /<h2>Jobs<\/h2>/);
+  assert.doesNotMatch(html, /<h2>Logs<\/h2>/);
+  assert.match(html, /\/_robodev\/state\.json/);
+  assert.doesNotMatch(html, /fetch\("\/_robodev\/logs\.json"\)/);
   assert.match(html, /setInterval\(poll, 1000\)/);
 });
+
+test("storageActivityMatchesKey uses exact key except list prefixes", () => {
+  assert.equal(storageActivityMatchesKey({ op: "upload", key: "a/b" }, "a/b"), true);
+  assert.equal(storageActivityMatchesKey({ op: "get", key: "a/b" }, "a/c"), false);
+  assert.equal(storageActivityMatchesKey({ op: "getUrl", key: "a/b" }, "a/b"), true);
+  assert.equal(storageActivityMatchesKey({ op: "delete", key: "a/b" }, "a/b"), true);
+  assert.equal(storageActivityMatchesKey({ op: "serve", key: "a/b" }, "a/b"), true);
+  assert.equal(storageActivityMatchesKey({ op: "list", key: "" }, "a/b"), true);
+  assert.equal(storageActivityMatchesKey({ op: "list", key: "a/" }, "a/b"), true);
+  assert.equal(storageActivityMatchesKey({ op: "list", key: "a/" }, "a/"), true);
+  assert.equal(storageActivityMatchesKey({ op: "list", key: "b" }, "a/b"), false);
+});
+
+test("socketEventMatchesDef matches path params or name", () => {
+  const chat = { path: "/sockets/chat", name: "chat" };
+  const room = { path: "/sockets/room/:id", name: "room" };
+  assert.equal(socketEventMatchesDef({ path: "/sockets/chat", name: "chat" }, chat), true);
+  assert.equal(socketEventMatchesDef({ name: "chat" }, chat), true);
+  assert.equal(socketEventMatchesDef({ path: "/sockets/other" }, chat), false);
+  assert.equal(socketEventMatchesDef({ path: "/sockets/room/abc" }, room), true);
+  assert.equal(socketEventMatchesDef({ name: "room" }, room), true);
+});
+
+test("truncateInspectPreview caps text and JSON at 200", () => {
+  assert.equal(truncateInspectPreview("short"), "short");
+  assert.equal(truncateInspectPreview({ a: 1 }), '{"a":1}');
+  const long = "x".repeat(220);
+  const preview = truncateInspectPreview(long);
+  assert.equal(preview.length, 201);
+  assert.equal(preview.endsWith("…"), true);
+});
+
+test("dashboard snapshot includes storage objects, activity, and socket defs", async () => {
+  const inspect = createDevInspect();
+  inspect.record({ kind: "storage", op: "upload", key: "a.png", ok: true });
+  inspect.record({ kind: "storage", op: "list", key: "", ok: true });
+  inspect.record({ kind: "storage", op: "serve", key: "missing", ok: false, error: "not_found" });
+  inspect.record({
+    kind: "socket",
+    socketKind: "connect",
+    path: "/sockets/chat",
+    name: "chat",
+    userId: "u1",
+  });
+  inspect.record({
+    kind: "socket",
+    socketKind: "send",
+    name: "chat",
+    preview: '{"hi":1}',
+  });
+
+  const pool = {
+    query: async <R extends Record<string, unknown>>(sql: string) => {
+      if (sql.includes("robodev_auth.users")) return { rows: [] as unknown as R[] };
+      if (sql.includes("count(*)") && sql.includes("robodev_storage.objects")) {
+        return { rows: [{ count: "2" }] as unknown as R[] };
+      }
+      if (sql.includes("robodev_storage.objects")) {
+        return {
+          rows: [
+            {
+              key: "a.png",
+              public: true,
+              size_bytes: 12,
+              content_type: "image/png",
+              created_at: new Date("2026-01-01T00:00:00.000Z"),
+            },
+          ] as unknown as R[],
+        };
+      }
+      return { rows: [] as unknown as R[] };
+    },
+  };
+
+  const state = await buildDashboardState({
+    inspect,
+    projectId: "local",
+    runtime: {
+      routes: [],
+      jobs: [],
+      sockets: [
+        { name: "chat", path: "/sockets/chat", file: "sockets/chat.ts", def: { auth: false } },
+      ],
+      pool,
+    },
+  });
+
+  assert.equal(state.overview.storageObjectCount, 2);
+  assert.equal(state.overview.socketCount, 1);
+  assert.equal(state.storage.objects.length, 1);
+  assert.equal(state.storage.objects[0]?.url, "/storage/objects/a.png");
+  assert.equal(state.storage.objects[0]?.sizeBytes, 12);
+  assert.equal(state.storage.activity.length, 3);
+  assert.equal(state.storage.activity[0]?.op, "serve");
+  assert.equal(state.sockets.defs[0]?.auth, "public");
+  assert.equal(state.sockets.connected, 0);
+  assert.equal(state.sockets.events.length, 2);
+  assert.equal(state.sockets.events[0]?.socketKind, "send");
+});
+
+test("storage object count is 0 when the query fails", async () => {
+  const state = await buildDashboardState({
+    inspect: createDevInspect(),
+    runtime: {
+      routes: [],
+      jobs: [],
+      pool: {
+        query: async () => {
+          throw new Error("missing schema");
+        },
+      },
+    },
+  });
+  assert.equal(state.overview.storageObjectCount, 0);
+  assert.deepEqual(state.storage.objects, []);
+});