mockpit 1.2.0 → 2.0.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, momentsOf, openCount, SURFACE_CONTENT_FIELDS, variantStatus, } from "./types.js";
 export const surfaceRef = (surface, index) => ({
     id: surface.id,
     kind: surface.kind,
@@ -24,6 +25,27 @@ export const hydratedSurfaceView = (surface, index) => {
     delete view[field];
     return view;
 };
+// The still overviews show for a version: its html page's poster.
+const pagePoster = (surfaces) => {
+    const page = surfaces.find((s) => s.kind === "html");
+    return page?.kind === "html" ? page.poster : undefined;
+};
+const posterOf = (surfaces) => {
+    const poster = pagePoster(surfaces);
+    return poster ? { poster } : {};
+};
+// The poster of one version of a variant: what Home shows for it.
+const posterAt = (post, version) => pagePoster((version === post.version
+    ? post.surfaces
+    : post.history.find((h) => h.version === version)?.surfaces) ?? []);
+// The in-use version's poster, when Home shows an older version than the
+// newest.
+const inUsePoster = (p) => {
+    if (p.acceptedVersion === undefined || p.acceptedVersion === p.version)
+        return {};
+    const poster = posterAt(p, p.acceptedVersion);
+    return poster ? { inUsePoster: poster } : {};
+};
 // One past version without its bodies: enough to list versions or pick one to
 // fetch, at a bounded cost.
 export const historyMetaView = (version) => ({
@@ -34,12 +56,13 @@ export const historyMetaView = (version) => ({
     ...(version.prompt ? { prompt: version.prompt } : {}),
     ...(version.author === undefined ? {} : { author: version.author }),
     surfaceKinds: version.surfaces.map((s) => s.kind),
+    ...posterOf(version.surfaces),
 });
 export const variantView = (post, opts = {}) => ({
     postId: post.id,
     state: post.state,
     variant: post.variant,
-    status: post.status,
+    status: variantStatus(post.status),
     version: post.version,
     title: post.title,
     sessionId: post.sessionId,
@@ -48,10 +71,23 @@ 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 part with fills 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 ? { fills: 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 ? {} : { inUseVersion: 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.
+    // which variants render a part (Borrow) without the html bodies.
     parts: partsInSurfaces(post.surfaces).map((p) => p.name),
     surfaces: post.surfaces.map(opts.body ? fullSurfaceView : hydratedSurfaceView),
     ...(opts.history
@@ -67,20 +103,32 @@ 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))),
     }));
 }
+// Where a mock sits in the product and the code that implements it, only once
+// declared, so the views of a project that names neither cost nothing.
+export const placeOf = (mock) => ({
+    ...(mock.area ? { area: mock.area } : {}),
+    ...(mock.source ? { source: mock.source } : {}),
+});
 // What Home shows for a mock: the first state's chosen (else first) variant.
 function thumbnail(mock, posts) {
     const first = stateOrder(mock)[0];
@@ -92,8 +140,13 @@ 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 };
+    const version = inUseVersion(pick);
+    const poster = posterAt(pick, version);
+    return { postId: pick.id, surface: Math.max(surface, 0), version, ...(poster ? { poster } : {}) };
 }
+// A mock's situations, only once it has any, so the views of mocks without
+// them are unchanged.
+const situationsOf = (mock) => Object.keys(mock.situations).length ? { situations: mock.situations } : {};
 export const mockSummaryView = (mock, posts) => {
     const drafted = draftedCount(mock, posts);
     return {
@@ -102,13 +155,16 @@ export const mockSummaryView = (mock, posts) => {
         slug: mock.slug,
         title: mock.title,
         kind: mock.kind,
+        ...placeOf(mock),
         states: mock.states,
-        stateCount: Math.max(mock.states.length, 1),
+        ...situationsOf(mock),
+        stateCount: Math.max(momentsOf(mock.states, mock.situations).length, 1),
         variants: posts.length,
         open: openCount(mock, posts),
         // Only once the user has started one, so a list with no drafts costs nothing.
         ...(drafted === null ? {} : { drafted }),
         sessionId: mock.sessionId,
+        closedAt: mock.closedAt,
         createdAt: mock.createdAt,
         updatedAt: mock.updatedAt,
         thumbnail: thumbnail(mock, posts),
@@ -122,19 +178,62 @@ export const mockDetailView = (mock, posts, opts = {}) => ({
     slug: mock.slug,
     title: mock.title,
     kind: mock.kind,
+    ...placeOf(mock),
     states: mock.states,
+    ...situationsOf(mock),
     asks: mock.asks,
     open: openCount(mock, posts),
     knobs: mock.knobs,
+    widths: mock.widths,
     sessionId: mock.sessionId,
+    closedAt: mock.closedAt,
     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 (`embeds`);
+// `embeddedIn` 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,
+    ...placeOf(mock),
+    open: openCount(mock, posts),
+    // Home shows a mock's states, never their situations.
+    states: mock.states.length ? momentsOf(mock.states, mock.situations) : [null],
+    widths: mock.widths,
+    createdAt: mock.createdAt,
+    updatedAt: mock.updatedAt,
+    closedAt: mock.closedAt,
+    settled: extra.settled,
+    embeds: extra.embeds,
+    embeddedIn: [],
+    inUse: inUseByState(mock, posts),
+    variants: posts.map((p) => ({
+        postId: p.id,
+        state: p.state,
+        variant: p.variant,
+        status: variantStatus(p.status),
+        version: p.version,
+        updatedAt: p.updatedAt,
+        surface: p.surfaces.findIndex((x) => isSandboxedSurfaceKind(x.kind)),
+        ...posterOf(p.surfaces),
+        ...inUsePoster(p),
+        ...(p.note ? { note: p.note } : {}),
+        ...(p.forkedFrom ? { forkedFrom: p.forkedFrom } : {}),
+        ...(p.starred ? { starred: true } : {}),
+        ...(p.acceptedVersion === undefined ? {} : { inUseVersion: p.acceptedVersion }),
+        ...(extra.embedViews.get(p.id) ? { embedsKey: extra.embedViews.get(p.id).key } : {}),
+    })),
+});

package/dist/server/app.d.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { type FeedEvent } from "./events.ts";
 import { type GuideTopic } from "./designGuide.ts";
+import { type GuidePack } from "./guidance.ts";
 import { type Executor, type RunLimits } from "./run.ts";
 import { type LogSink } from "./eventLog.ts";
 import { type Store } from "./types.ts";
@@ -14,6 +15,8 @@ export interface AppOptions {
     viewerHtml: string;
     setupText: string;
     topics?: Partial<Record<GuideTopic, string>>;
+    packs?: Partial<Record<GuidePack, string>>;
+    userRules?: () => Promise<string | null>;
     authenticate?: AuthenticateHook;
     authToken?: string;
     basePath?: BasePathHook;
@@ -21,6 +24,7 @@ export interface AppOptions {
     screenshots?: boolean;
     version?: string;
     upgradeCommand?: string;
+    renderRev?: string;
     fetchLatestRelease?: () => Promise<LatestRelease | null>;
     onEvent?: (event: FeedEvent) => void;
     maxHoldConnections?: number;
@@ -52,4 +56,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, packs, userRules, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, renderRev, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, log, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;