mockpit 1.2.0 → 1.3.0

package/dist/server/apiViews.js

@@ -1,7 +1,8 @@
 // Response shapes shared by every tier (REST, both MCP transports, the CLI), so
 // one mock reads the same however an agent asks for it.
+import { slotKnobs, slotsInSurfaces } from "./fills.js";
 import { mergeParts, partsInSurfaces } from "./parts.js";
-import { isSandboxedSurfaceKind, draftedCount, openCount, SURFACE_CONTENT_FIELDS, } from "./types.js";
+import { draftedCount, inUseVersion, isSandboxedSurfaceKind, isLive, openCount, SURFACE_CONTENT_FIELDS, } from "./types.js";
 export const surfaceRef = (surface, index) => ({
     id: surface.id,
     kind: surface.kind,
@@ -48,8 +49,21 @@ export const variantView = (post, opts = {}) => ({
     ...(post.from === undefined ? {} : { from: post.from }),
     ...(post.prompt ? { prompt: post.prompt } : {}),
     ...(post.author === undefined ? {} : { author: post.author }),
-    ...(post.knobs ? { knobs: post.knobs } : {}),
-    ...(post.slots.length ? { slots: post.slots } : {}),
+    // A slot is a select knob on its part (fills.ts); declared knobs win.
+    ...(slotsInSurfaces(post.surfaces).length || post.knobs
+        ? { knobs: { ...slotKnobs(slotsInSurfaces(post.surfaces)), ...post.knobs } }
+        : {}),
+    ...(slotsInSurfaces(post.surfaces).length ? { slots: slotsInSurfaces(post.surfaces) } : {}),
+    ...(post.note ? { note: post.note } : {}),
+    // Embedded components as they render now (server/embeds.ts); `publishedWith`
+    // is what this version rendered with when it was published.
+    ...(opts.embeds?.get(post.id)
+        ? { embeds: opts.embeds.get(post.id).list, embedsKey: opts.embeds.get(post.id).key }
+        : {}),
+    ...(post.embeds.length ? { publishedWith: post.embeds } : {}),
+    ...(post.forkedFrom ? { forkedFrom: post.forkedFrom } : {}),
+    ...(post.starred ? { starred: true } : {}),
+    ...(post.acceptedVersion === undefined ? {} : { acceptedVersion: post.acceptedVersion }),
     // The part names this variant's own markup marks, so the viewer can tell
     // which looks render a part (Mix) without the html bodies.
     parts: partsInSurfaces(post.surfaces).map((p) => p.name),
@@ -67,17 +81,23 @@ export const variantView = (post, opts = {}) => ({
                     ...(post.author === undefined ? {} : { author: post.author }),
                 }),
                 ...[...post.history].sort((a, b) => b.version - a.version).map(historyMetaView),
-            ],
+            ].map((row) => post.hiddenVersions?.includes(row.version) ? { ...row, hidden: true } : row),
         }
         : {}),
 });
 const stateOrder = (mock) => (mock.states.length ? mock.states : [null]);
+// What the user put in use, per state, in the mock's order; a state with
+// nothing accepted is absent. Export and embeds resolve to exactly these.
+export const inUseByState = (mock, posts) => stateOrder(mock).flatMap((state) => {
+    const p = posts.find((x) => x.state === state && x.status === "accepted");
+    return p ? [{ state, variant: p.variant, version: inUseVersion(p) }] : [];
+});
 // The parts the agent marked, per state, across the variants still in play.
 export function partsByState(mock, posts) {
     return stateOrder(mock).map((state) => ({
         state,
         parts: mergeParts(posts
-            .filter((p) => p.state === state && p.status !== "archived")
+            .filter((p) => p.state === state && isLive(p.status))
             .map((p) => partsInSurfaces(p.surfaces))),
     }));
 }
@@ -92,7 +112,7 @@ function thumbnail(mock, posts) {
     if (!pick)
         return null;
     const surface = pick.surfaces.findIndex((s) => isSandboxedSurfaceKind(s.kind));
-    return { postId: pick.id, surface: Math.max(surface, 0), version: pick.version };
+    return { postId: pick.id, surface: Math.max(surface, 0), version: inUseVersion(pick) };
 }
 export const mockSummaryView = (mock, posts) => {
     const drafted = draftedCount(mock, posts);
@@ -109,6 +129,7 @@ export const mockSummaryView = (mock, posts) => {
         // Only once the user has started one, so a list with no drafts costs nothing.
         ...(drafted === null ? {} : { drafted }),
         sessionId: mock.sessionId,
+        resolvedAt: mock.resolvedAt,
         createdAt: mock.createdAt,
         updatedAt: mock.updatedAt,
         thumbnail: thumbnail(mock, posts),
@@ -126,15 +147,52 @@ export const mockDetailView = (mock, posts, opts = {}) => ({
     asks: mock.asks,
     open: openCount(mock, posts),
     knobs: mock.knobs,
+    widths: mock.widths,
     sessionId: mock.sessionId,
+    resolvedAt: mock.resolvedAt,
     createdAt: mock.createdAt,
     updatedAt: mock.updatedAt,
     variants: posts.map((p) => variantView(p, opts)),
+    inUse: inUseByState(mock, posts),
     parts: partsByState(mock, posts),
-    // The knob values of the latest reply — what the user last sent, not drafts.
-    tuned: opts.tuned ?? {},
+    // Every knob value the user has sent (answers' sets and tuning, later replies
+    // winning), never drafts. Later questions render on top of it.
+    settled: opts.settled ?? {},
 });
 export const sessionRowView = (session, postCount) => ({
     ...session,
     postCount,
 });
+// One mock as a node of the project tree (GET /api/projects/:name/tree): its
+// variants per state with status and lineage, and the mocks it embeds (`uses`);
+// `usedIn` is filled in once every node is known.
+export const treeNodeView = (mock, posts, extra) => ({
+    id: mock.id,
+    slug: mock.slug,
+    title: mock.title,
+    kind: mock.kind,
+    open: openCount(mock, posts),
+    states: mock.states.length ? mock.states : [null],
+    widths: mock.widths,
+    createdAt: mock.createdAt,
+    updatedAt: mock.updatedAt,
+    resolvedAt: mock.resolvedAt,
+    settled: extra.settled,
+    uses: extra.uses,
+    usedIn: [],
+    inUse: inUseByState(mock, posts),
+    variants: posts.map((p) => ({
+        postId: p.id,
+        state: p.state,
+        variant: p.variant,
+        status: p.status,
+        version: p.version,
+        updatedAt: p.updatedAt,
+        surface: p.surfaces.findIndex((x) => isSandboxedSurfaceKind(x.kind)),
+        ...(p.note ? { note: p.note } : {}),
+        ...(p.forkedFrom ? { forkedFrom: p.forkedFrom } : {}),
+        ...(p.starred ? { starred: true } : {}),
+        ...(p.acceptedVersion === undefined ? {} : { acceptedVersion: p.acceptedVersion }),
+        ...(extra.embeds.get(p.id) ? { embedsKey: extra.embeds.get(p.id).key } : {}),
+    })),
+});

package/dist/server/app.d.ts

@@ -21,6 +21,7 @@ export interface AppOptions {
     screenshots?: boolean;
     version?: string;
     upgradeCommand?: string;
+    renderRev?: string;
     fetchLatestRelease?: () => Promise<LatestRelease | null>;
     onEvent?: (event: FeedEvent) => void;
     maxHoldConnections?: number;
@@ -52,4 +53,4 @@ export interface FlowContext {
     request?: Request;
     signal?: AbortSignal;
 }
-export declare function createApp({ store, viewerHtml, setupText, topics, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, log, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function createApp({ store, viewerHtml, setupText, topics, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, renderRev, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, log, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;