mockpit 1.1.0 → 1.3.0

package/dist/server/apiViews.d.ts

@@ -1,5 +1,5 @@
 import { type PartInfo } from "./parts.ts";
-import { type Mock, type Post, type PostVersion, type Session, type Surface } from "./types.ts";
+import { type Embed, type KnobValue, type Mock, type Post, type PostVersion, type Session, type Surface } from "./types.ts";
 export declare const surfaceRef: (surface: Pick<Surface, "id" | "kind">, index: number) => {
     id: string | undefined;
     kind: "html" | "diff" | "image" | "markdown" | "terminal" | "mermaid" | "json" | "code";
@@ -56,7 +56,7 @@ export declare const fullSurfaceView: (surface: Surface, index: number) => {
     lineStart?: number;
     id?: string;
 };
-export declare const hydratedSurfaceView: (surface: Surface, index: number) => Record<string, unknown> | {
+export declare const hydratedSurfaceView: (surface: Surface, index: number) => {
     index: number;
     kind: "html";
     html: string;
@@ -106,7 +106,7 @@ export declare const hydratedSurfaceView: (surface: Surface, index: number) => R
     title?: string;
     lineStart?: number;
     id?: string;
-};
+} | Record<string, unknown>;
 export declare const historyMetaView: (version: PostVersion) => {
     surfaceKinds: ("html" | "diff" | "image" | "markdown" | "terminal" | "mermaid" | "json" | "code")[];
     author?: string | undefined;
@@ -119,9 +119,17 @@ export declare const historyMetaView: (version: PostVersion) => {
 export interface VariantViewOptions {
     body?: boolean;
     history?: boolean;
+    embeds?: Map<string, EmbedView>;
+}
+export interface EmbedView {
+    key: string;
+    list: (Embed & {
+        latest: number;
+        versions: number[];
+    })[];
 }
 export declare const variantView: (post: Post, opts?: VariantViewOptions) => {
-    history?: {
+    history?: ({
         surfaceKinds: ("html" | "diff" | "image" | "markdown" | "terminal" | "mermaid" | "json" | "code")[];
         author?: string | undefined;
         prompt?: string | undefined;
@@ -129,9 +137,18 @@ export declare const variantView: (post: Post, opts?: VariantViewOptions) => {
         version: number;
         title: string;
         at: string;
-    }[] | undefined;
+    } | {
+        hidden: true;
+        surfaceKinds: ("html" | "diff" | "image" | "markdown" | "terminal" | "mermaid" | "json" | "code")[];
+        author?: string | undefined;
+        prompt?: string | undefined;
+        from?: number | undefined;
+        version: number;
+        title: string;
+        at: string;
+    })[] | undefined;
     parts: string[];
-    surfaces: (Record<string, unknown> | {
+    surfaces: ({
         index: number;
         kind: "html";
         html: string;
@@ -181,9 +198,21 @@ export declare const variantView: (post: Post, opts?: VariantViewOptions) => {
         title?: string;
         lineStart?: number;
         id?: string;
-    })[];
-    slots?: import("./types.ts").Slot[] | undefined;
-    knobs?: import("./types.ts").Knobs | undefined;
+    } | Record<string, unknown>)[];
+    acceptedVersion?: number | undefined;
+    starred?: boolean | undefined;
+    forkedFrom?: import("./types.ts").ForkRef | undefined;
+    publishedWith?: Embed[] | undefined;
+    embeds?: (Embed & {
+        latest: number;
+        versions: number[];
+    })[] | undefined;
+    embedsKey?: string | undefined;
+    note?: string | undefined;
+    slots?: import("./fills.ts").SlotInfo[] | undefined;
+    knobs?: {
+        [x: string]: import("./types.ts").KnobConfig;
+    } | undefined;
     author?: string | undefined;
     prompt?: string | undefined;
     from?: number | undefined;
@@ -197,12 +226,27 @@ export declare const variantView: (post: Post, opts?: VariantViewOptions) => {
     createdAt: string;
     updatedAt: string;
 };
+export declare const inUseByState: (mock: Mock, posts: Post[]) => {
+    state: string | null;
+    variant: string;
+    version: number;
+}[];
 export interface StateParts {
     state: string | null;
     parts: PartInfo[];
 }
 export declare function partsByState(mock: Mock, posts: Post[]): StateParts[];
 export declare const mockSummaryView: (mock: Mock, posts: Post[]) => {
+    sessionId: string | null;
+    resolvedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    thumbnail: {
+        postId: string;
+        surface: number;
+        version: number;
+    } | null;
+    drafted?: number | undefined;
     id: string;
     project: string;
     slug: string;
@@ -212,17 +256,9 @@ export declare const mockSummaryView: (mock: Mock, posts: Post[]) => {
     stateCount: number;
     variants: number;
     open: number;
-    sessionId: string | null;
-    createdAt: string;
-    updatedAt: string;
-    thumbnail: {
-        postId: string;
-        surface: number;
-        version: number;
-    } | null;
 };
 export declare const mockDetailView: (mock: Mock, posts: Post[], opts?: VariantViewOptions & {
-    tuned?: Record<string, unknown>;
+    settled?: Record<string, KnobValue>;
 }) => {
     id: string;
     project: string;
@@ -233,11 +269,13 @@ export declare const mockDetailView: (mock: Mock, posts: Post[], opts?: VariantV
     asks: import("./types.ts").Ask[];
     open: number;
     knobs: import("./types.ts").Knobs;
+    widths: number[];
     sessionId: string | null;
+    resolvedAt: string | null;
     createdAt: string;
     updatedAt: string;
     variants: {
-        history?: {
+        history?: ({
             surfaceKinds: ("html" | "diff" | "image" | "markdown" | "terminal" | "mermaid" | "json" | "code")[];
             author?: string | undefined;
             prompt?: string | undefined;
@@ -245,9 +283,18 @@ export declare const mockDetailView: (mock: Mock, posts: Post[], opts?: VariantV
             version: number;
             title: string;
             at: string;
-        }[] | undefined;
+        } | {
+            hidden: true;
+            surfaceKinds: ("html" | "diff" | "image" | "markdown" | "terminal" | "mermaid" | "json" | "code")[];
+            author?: string | undefined;
+            prompt?: string | undefined;
+            from?: number | undefined;
+            version: number;
+            title: string;
+            at: string;
+        })[] | undefined;
         parts: string[];
-        surfaces: (Record<string, unknown> | {
+        surfaces: ({
             index: number;
             kind: "html";
             html: string;
@@ -297,9 +344,21 @@ export declare const mockDetailView: (mock: Mock, posts: Post[], opts?: VariantV
             title?: string;
             lineStart?: number;
             id?: string;
-        })[];
-        slots?: import("./types.ts").Slot[] | undefined;
-        knobs?: import("./types.ts").Knobs | undefined;
+        } | Record<string, unknown>)[];
+        acceptedVersion?: number | undefined;
+        starred?: boolean | undefined;
+        forkedFrom?: import("./types.ts").ForkRef | undefined;
+        publishedWith?: Embed[] | undefined;
+        embeds?: (Embed & {
+            latest: number;
+            versions: number[];
+        })[] | undefined;
+        embedsKey?: string | undefined;
+        note?: string | undefined;
+        slots?: import("./fills.ts").SlotInfo[] | undefined;
+        knobs?: {
+            [x: string]: import("./types.ts").KnobConfig;
+        } | undefined;
         author?: string | undefined;
         prompt?: string | undefined;
         from?: number | undefined;
@@ -313,8 +372,13 @@ export declare const mockDetailView: (mock: Mock, posts: Post[], opts?: VariantV
         createdAt: string;
         updatedAt: string;
     }[];
+    inUse: {
+        state: string | null;
+        variant: string;
+        version: number;
+    }[];
     parts: StateParts[];
-    tuned: Record<string, unknown>;
+    settled: Record<string, KnobValue>;
 };
 export declare const sessionRowView: (session: Session, postCount: number) => {
     postCount: number;
@@ -326,4 +390,44 @@ export declare const sessionRowView: (session: Session, postCount: number) => {
     lastActiveAt: string;
     agentSeq: number;
     project: string | null;
+    agentActiveAt: string | null;
+    keyed: boolean;
+};
+export declare const treeNodeView: (mock: Mock, posts: Post[], extra: {
+    settled: Record<string, KnobValue>;
+    uses: string[];
+    embeds: Map<string, EmbedView>;
+}) => {
+    id: string;
+    slug: string;
+    title: string;
+    kind: import("./types.ts").MockKind;
+    open: number;
+    states: string[] | null[];
+    widths: number[];
+    createdAt: string;
+    updatedAt: string;
+    resolvedAt: string | null;
+    settled: Record<string, KnobValue>;
+    uses: string[];
+    usedIn: string[];
+    inUse: {
+        state: string | null;
+        variant: string;
+        version: number;
+    }[];
+    variants: {
+        embedsKey?: string | undefined;
+        acceptedVersion?: number | undefined;
+        starred?: boolean | undefined;
+        forkedFrom?: import("./types.ts").ForkRef | undefined;
+        note?: string | undefined;
+        postId: string;
+        state: string | null;
+        variant: string;
+        status: import("./types.ts").PostStatus;
+        version: number;
+        updatedAt: string;
+        surface: number;
+    }[];
 };

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, 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,23 +112,29 @@ 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) => ({
-    id: mock.id,
-    project: mock.project,
-    slug: mock.slug,
-    title: mock.title,
-    kind: mock.kind,
-    states: mock.states,
-    stateCount: Math.max(mock.states.length, 1),
-    variants: posts.length,
-    open: openCount(mock, posts),
-    sessionId: mock.sessionId,
-    createdAt: mock.createdAt,
-    updatedAt: mock.updatedAt,
-    thumbnail: thumbnail(mock, posts),
-});
+export const mockSummaryView = (mock, posts) => {
+    const drafted = draftedCount(mock, posts);
+    return {
+        id: mock.id,
+        project: mock.project,
+        slug: mock.slug,
+        title: mock.title,
+        kind: mock.kind,
+        states: mock.states,
+        stateCount: Math.max(mock.states.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,
+        resolvedAt: mock.resolvedAt,
+        createdAt: mock.createdAt,
+        updatedAt: mock.updatedAt,
+        thumbnail: thumbnail(mock, posts),
+    };
+};
 // One mock as anyone outside the viewer's own draft sees it: the draft is the
 // user's unsent work and never leaves through this view.
 export const mockDetailView = (mock, posts, opts = {}) => ({
@@ -121,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, "/">;