mockpit 1.3.0 → 3.0.0

package/dist/server/apiViews.js

@@ -1,8 +1,9 @@
 // Response shapes shared by every tier (REST, both MCP transports, the CLI), so
-// one mock reads the same however an agent asks for it.
+// one design reads the same however an agent asks for it.
 import { slotKnobs, slotsInSurfaces } from "./fills.js";
 import { mergeParts, partsInSurfaces } from "./parts.js";
-import { draftedCount, inUseVersion, isSandboxedSurfaceKind, isLive, openCount, SURFACE_CONTENT_FIELDS, } from "./types.js";
+import { isKeptVariant, keptVariants } from "./standings.js";
+import { changedTo, currentVersion, draftedCount, inUseVersion, isPlanned, isSandboxedSurfaceKind, isLive, openCount, recommendedVariant, SURFACE_CONTENT_FIELDS, variantStatus, } from "./types.js";
 export const surfaceRef = (surface, index) => ({
     id: surface.id,
     kind: surface.kind,
@@ -25,6 +26,72 @@ export const hydratedSurfaceView = (surface, index) => {
     delete view[field];
     return view;
 };
+// A still mockpit took shows the page in the mode it was taken in. In the other mode it
+// would be the one picture in the wrong colours among live pages, so it is left out and the
+// page runs as it did before posters. Applied to posts before any view reads them, so every
+// view agrees. Posts come from the store's cache: copied where changed, never written to.
+const otherMode = (s, mode) => {
+    const taken = s.posterMode;
+    return s.kind === "html" && taken !== undefined && taken !== mode;
+};
+const surfacesFor = (surfaces, mode) => surfaces.some((s) => otherMode(s, mode))
+    ? surfaces.map((s) => {
+        if (!otherMode(s, mode))
+            return s;
+        const { poster: _poster, posterMode: _mode, ...rest } = s;
+        return rest;
+    })
+    : surfaces;
+export const postersFor = (posts, mode) => posts.map((p) => {
+    const surfaces = surfacesFor(p.surfaces, mode);
+    const history = p.history.map((h) => {
+        const own = surfacesFor(h.surfaces, mode);
+        return own === h.surfaces ? h : { ...h, surfaces: own };
+    });
+    return surfaces === p.surfaces && history.every((h, i) => h === p.history[i])
+        ? p
+        : { ...p, surfaces, history };
+});
+// The still overviews show for a version: its html page's poster.
+const pagePoster = (surfaces) => surfaces.find((s) => s.kind === "html")?.poster;
+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 } : {};
+};
+// The version Home shows when nothing is in use and the newest was hidden.
+const coverVersion = (p) => {
+    const at = currentVersion(p);
+    if (p.status === "accepted" || at === p.version)
+        return {};
+    const poster = posterAt(p, at);
+    return { coverVersion: at, ...(poster ? { coverPoster: poster } : {}) };
+};
+// A page that draws on a canvas may hold a WebGL context, of which a browser
+// keeps about 16 and drops the oldest past that, so overviews ration these
+// frames and no others. Three.js and the like make their canvas from script.
+// Asked once per version: a read lists every version, with bodies up to 1 MB.
+const CANVAS_PAGE = /<canvas[\s>]|webgl|three(?:\.module|\.min|\.js|@)|['"]three['"]|pixi|babylon/i;
+const canvasPages = new WeakMap();
+const drawsOnCanvas = (surfaces) => {
+    let hit = canvasPages.get(surfaces);
+    if (hit === undefined) {
+        hit = surfaces.some((s) => s.kind === "html" && CANVAS_PAGE.test(s.html));
+        canvasPages.set(surfaces, hit);
+    }
+    return hit;
+};
 // One past version without its bodies: enough to list versions or pick one to
 // fetch, at a bounded cost.
 export const historyMetaView = (version) => ({
@@ -34,13 +101,16 @@ export const historyMetaView = (version) => ({
     ...(version.from === undefined ? {} : { from: version.from }),
     ...(version.prompt ? { prompt: version.prompt } : {}),
     ...(version.author === undefined ? {} : { author: version.author }),
+    ...(version.amendedAt ? { amendedAt: version.amendedAt } : {}),
     surfaceKinds: version.surfaces.map((s) => s.kind),
+    ...posterOf(version.surfaces),
+    ...(drawsOnCanvas(version.surfaces) ? { canvas: true } : {}),
 });
 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,
@@ -49,12 +119,15 @@ export const variantView = (post, opts = {}) => ({
     ...(post.from === undefined ? {} : { from: post.from }),
     ...(post.prompt ? { prompt: post.prompt } : {}),
     ...(post.author === undefined ? {} : { author: post.author }),
-    // A slot is a select knob on its part (fills.ts); declared knobs win.
+    ...(post.amendedAt ? { amendedAt: post.amendedAt } : {}),
+    // Frame URLs carry it (`w`): an amended version keeps its number.
+    ...(post.rewrites ? { rewrites: post.rewrites } : {}),
+    // 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 ? { slots: slotsInSurfaces(post.surfaces) } : {}),
-    ...(post.note ? { note: post.note } : {}),
+    ...(slotsInSurfaces(post.surfaces).length ? { fills: slotsInSurfaces(post.surfaces) } : {}),
+    ...(post.description ? { description: post.description } : {}),
     // 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)
@@ -62,10 +135,13 @@ export const variantView = (post, opts = {}) => ({
         : {}),
     ...(post.embeds.length ? { publishedWith: post.embeds } : {}),
     ...(post.forkedFrom ? { forkedFrom: post.forkedFrom } : {}),
-    ...(post.starred ? { starred: true } : {}),
-    ...(post.acceptedVersion === undefined ? {} : { acceptedVersion: post.acceptedVersion }),
+    ...(post.copiedFrom ? { copiedFrom: post.copiedFrom } : {}),
+    ...(opts.kept && isKeptVariant(opts.kept, post) ? { kept: true } : {}),
+    ...(post.acceptedVersion === undefined ? {} : { inUseVersion: post.acceptedVersion }),
+    ...(changedTo(post) === undefined ? {} : { changedTo: changedTo(post) }),
+    ...(post.archiveReason ? { archiveReason: post.archiveReason } : {}),
     // 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
@@ -79,82 +155,124 @@ export const variantView = (post, opts = {}) => ({
                     ...(post.from === undefined ? {} : { from: post.from }),
                     ...(post.prompt === undefined ? {} : { prompt: post.prompt }),
                     ...(post.author === undefined ? {} : { author: post.author }),
+                    ...(post.amendedAt ? { amendedAt: post.amendedAt } : {}),
                 }),
                 ...[...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
+const stateOrder = (design) => (design.states.length ? design.states : [null]);
+// What the user put in use, per state, in the design'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) => {
+export const inUseByState = (design, posts) => stateOrder(design).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) => ({
+export function partsByState(design, posts) {
+    return stateOrder(design).map((state) => ({
         state,
         parts: mergeParts(posts
             .filter((p) => p.state === state && isLive(p.status))
             .map((p) => partsInSurfaces(p.surfaces))),
     }));
 }
-// What Home shows for a mock: the first state's chosen (else first) variant.
-function thumbnail(mock, posts) {
-    const first = stateOrder(mock)[0];
+// Where a design 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 = (design) => ({
+    ...(design.area ? { area: design.area } : {}),
+    ...(design.source ? { source: design.source } : {}),
+});
+// What a design's first state looks like in a list: what's in use, else what the agent
+// recommends, else its first. Same rule as viewer/src/logic.ts screenPicture.
+function thumbnail(design, posts) {
+    const first = stateOrder(design)[0];
     const inState = posts.filter((p) => p.state === first);
+    const recommended = recommendedVariant(design.asks, first);
     const pick = inState.find((p) => p.status === "accepted") ??
+        inState.find((p) => p.variant === recommended && isLive(p.status)) ??
         inState.find((p) => p.status === "open") ??
         inState[0] ??
         posts[0];
     if (!pick)
         return null;
     const surface = pick.surfaces.findIndex((s) => isSandboxedSurfaceKind(s.kind));
-    return { postId: pick.id, surface: Math.max(surface, 0), version: inUseVersion(pick) };
+    const version = currentVersion(pick);
+    const poster = posterAt(pick, version);
+    return {
+        postId: pick.id,
+        surface: Math.max(surface, 0),
+        version,
+        ...(poster ? { poster } : {}),
+        ...(pick.rewrites ? { rewrites: pick.rewrites } : {}),
+    };
 }
-export const mockSummaryView = (mock, posts) => {
-    const drafted = draftedCount(mock, posts);
+// Only a plan says so, so the views of everything drawn are unchanged.
+const plannedOf = (design, variants) => isPlanned(design, variants) ? { planned: true } : {};
+// Anything the user has yet to send. A stored draft can be an emptied one, which
+// waits on nobody.
+export const draftHolds = (draft) => !!draft &&
+    (draft.comments.length > 0 ||
+        Object.values(draft.answers).some((a) => !Array.isArray(a) || a.length > 0) ||
+        [draft.borrowed, draft.tuned, draft.others ?? {}, draft.askComments ?? {}].some((rec) => Object.keys(rec).length > 0));
+export const designSummaryView = (design, posts) => {
+    const drafted = draftedCount(design);
     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),
+        id: design.id,
+        project: design.project,
+        slug: design.slug,
+        title: design.title,
+        kind: design.kind,
+        ...placeOf(design),
+        ...plannedOf(design, posts.length),
+        // Text comes with a read of the design; a list only says there is some to read.
+        ...(design.notes ? { hasNotes: true } : {}),
+        states: design.states,
+        stateCount: Math.max(design.states.length, 1),
         variants: posts.length,
-        open: openCount(mock, posts),
+        open: openCount(design),
         // 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),
+        sessionId: design.sessionId,
+        archivedAt: design.archivedAt,
+        createdAt: design.createdAt,
+        updatedAt: design.updatedAt,
+        thumbnail: thumbnail(design, posts),
     };
 };
-// One mock as anyone outside the viewer's own draft sees it: the draft is the
+// One design 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 = {}) => ({
-    id: mock.id,
-    project: mock.project,
-    slug: mock.slug,
-    title: mock.title,
-    kind: mock.kind,
-    states: mock.states,
-    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),
+export const designDetailView = (design, posts, opts = {}) => ({
+    id: design.id,
+    project: design.project,
+    slug: design.slug,
+    title: design.title,
+    kind: design.kind,
+    ...placeOf(design),
+    ...(design.shortlist ? { shortlist: true } : {}),
+    // No agent has written to this shortlist yet: who its replies reach for now.
+    ...(opts.repliesGoTo ? { repliesGoTo: opts.repliesGoTo } : {}),
+    ...plannedOf(design, posts.length),
+    states: design.states,
+    ...(design.notes ? { notes: design.notes } : {}),
+    ...(Object.keys(design.stateOutlines).length ? { stateOutlines: design.stateOutlines } : {}),
+    ...(design.answerAdditions.length ? { answerAdditions: design.answerAdditions } : {}),
+    asks: design.asks,
+    // By question id: the answers the user kept for later and hid, with why.
+    ...(Object.keys(design.standings).length ? { standings: design.standings } : {}),
+    ...(design.sets.length ? { sets: design.sets } : {}),
+    open: openCount(design),
+    knobs: design.knobs,
+    widths: design.widths,
+    sessionId: design.sessionId,
+    archivedAt: design.archivedAt,
+    ...(design.archiveReason ? { archiveReason: design.archiveReason } : {}),
+    createdAt: design.createdAt,
+    updatedAt: design.updatedAt,
+    variants: ((kept) => posts.map((p) => variantView(p, { ...opts, kept })))(keptVariants(design, posts)),
+    inUse: inUseByState(design, posts),
+    parts: partsByState(design, posts),
     // 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 ?? {},
@@ -163,36 +281,67 @@ 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,
+// One design as a node of the project tree (GET /api/projects/:name/tree): its
+// variants per state with status and lineage, and the designs it embeds (`embeds`);
+// `embeddedIn` is filled in once every node is known.
+// When it left the shelf: archived by hand, or with the last of its variants archived.
+// Designs archived before the date was kept fall back on the design's last change.
+function leftOf(design, posts) {
+    if (design.archivedAt)
+        return { leftAt: design.archivedAt };
+    if (!posts.length || posts.some((p) => isLive(p.status)))
+        return {};
+    const last = posts.reduce((t, p) => (p.archivedAt && p.archivedAt > t ? p.archivedAt : t), "");
+    return { leftAt: last || design.updatedAt };
+}
+export const treeNodeView = (design, posts, extra) => ({
+    id: design.id,
+    slug: design.slug,
+    title: design.title,
+    kind: design.kind,
+    ...placeOf(design),
+    ...(design.shortlist ? { shortlist: true } : {}),
+    ...plannedOf(design, posts.length),
+    open: openCount(design),
+    // Any question ever asked, answered or not: it tells an idea from a document.
+    ...(design.asks.length ? { asked: design.asks.length } : {}),
+    // Later than every variant: the user has spoken and it is the agent's turn.
+    ...(extra.lastReplyAt ? { lastReplyAt: extra.lastReplyAt } : {}),
+    ...(extra.lastSend ? { lastSend: extra.lastSend } : {}),
+    ...(extra.drafting ? { drafting: true } : {}),
+    states: stateOrder(design),
+    widths: design.widths,
+    createdAt: design.createdAt,
+    updatedAt: design.updatedAt,
+    archivedAt: design.archivedAt,
+    ...leftOf(design, posts),
+    ...(design.archiveReason ? { archiveReason: design.archiveReason } : {}),
     settled: extra.settled,
-    uses: extra.uses,
-    usedIn: [],
-    inUse: inUseByState(mock, posts),
+    embeds: extra.embeds,
+    embeddedIn: [],
+    inUse: inUseByState(design, posts),
+    // What the agent recommends where nothing is in use: a cover shows it.
+    recommended: stateOrder(design).flatMap((state) => {
+        const variant = recommendedVariant(design.asks, state);
+        return variant ? [{ state, variant }] : [];
+    }),
     variants: posts.map((p) => ({
         postId: p.id,
         state: p.state,
         variant: p.variant,
-        status: p.status,
+        status: variantStatus(p.status),
         version: p.version,
         updatedAt: p.updatedAt,
+        ...(p.rewrites ? { rewrites: p.rewrites } : {}),
         surface: p.surfaces.findIndex((x) => isSandboxedSurfaceKind(x.kind)),
-        ...(p.note ? { note: p.note } : {}),
+        ...posterOf(p.surfaces),
+        ...inUsePoster(p),
+        ...coverVersion(p),
+        ...(p.description && !extra.noDescriptions ? { description: p.description } : {}),
         ...(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 } : {}),
+        ...(p.acceptedVersion === undefined ? {} : { inUseVersion: p.acceptedVersion }),
+        ...(changedTo(p) === undefined ? {} : { changedTo: changedTo(p) }),
+        ...(p.archiveReason ? { archiveReason: p.archiveReason } : {}),
+        ...(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;
@@ -27,6 +30,10 @@ export interface AppOptions {
     maxHoldConnections?: number;
     executor?: Executor;
     runLimits?: Partial<RunLimits>;
+    networkHosts?: () => {
+        localOnly: boolean;
+        hosts: string[];
+    };
     log?: LogSink;
 }
 export interface LatestRelease {
@@ -35,12 +42,13 @@ export interface LatestRelease {
 }
 export interface CommentWait {
     sessionId?: string;
-    mockId?: string;
+    designId?: string;
     postId?: string;
     author?: string;
     afterSeq?: number;
     waitSeconds: number;
     agent?: boolean;
+    peek?: boolean;
 }
 export interface FlowResult {
     status: number;
@@ -53,4 +61,4 @@ export interface FlowContext {
     request?: Request;
     signal?: AbortSignal;
 }
-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, "/">;
+export declare function createApp({ store, viewerHtml, setupText, topics, packs, userRules, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, renderRev, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, networkHosts, log, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;