mockpit 0.0.0-stage → 1.0.0

package/dist/server/apiViews.js

@@ -0,0 +1,135 @@
+// 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 { mergeParts, partsInSurfaces } from "./parts.js";
+import { isSandboxedSurfaceKind, openCount, SURFACE_CONTENT_FIELDS, } from "./types.js";
+export const surfaceRef = (surface, index) => ({
+    id: surface.id,
+    kind: surface.kind,
+    index,
+});
+export const fullSurfaceView = (surface, index) => ({ ...surface, index });
+// A sandboxed surface renders as an opaque-origin iframe pointed at
+// /s/:id?surface=N, which fetches the body itself — so a read that is not asking
+// for bodies drops just the content field. Native kinds (image/json) render from
+// inline data, so they keep everything.
+export const hydratedSurfaceView = (surface, index) => {
+    const field = isSandboxedSurfaceKind(surface.kind)
+        ? SURFACE_CONTENT_FIELDS[surface.kind]
+        : undefined;
+    if (!field)
+        return fullSurfaceView(surface, index);
+    // Surface is a union of interfaces, so the content key can't be dropped through
+    // the union type. Widen to a bag, delete the one key; the value is only serialized.
+    const view = { ...surface, index };
+    delete view[field];
+    return view;
+};
+// One past version without its bodies: enough to list versions or pick one to
+// fetch, at a bounded cost.
+export const historyMetaView = (version) => ({
+    version: version.version,
+    title: version.title,
+    at: version.at,
+    ...(version.from === undefined ? {} : { from: version.from }),
+    ...(version.prompt ? { prompt: version.prompt } : {}),
+    ...(version.author === undefined ? {} : { author: version.author }),
+    surfaceKinds: version.surfaces.map((s) => s.kind),
+});
+export const variantView = (post, opts = {}) => ({
+    postId: post.id,
+    state: post.state,
+    variant: post.variant,
+    status: post.status,
+    version: post.version,
+    title: post.title,
+    sessionId: post.sessionId,
+    createdAt: post.createdAt,
+    updatedAt: post.updatedAt,
+    ...(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 } : {}),
+    // 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),
+    surfaces: post.surfaces.map(opts.body ? fullSurfaceView : hydratedSurfaceView),
+    ...(opts.history
+        ? {
+            history: [
+                historyMetaView({
+                    version: post.version,
+                    title: post.title,
+                    surfaces: post.surfaces,
+                    at: post.updatedAt,
+                    ...(post.from === undefined ? {} : { from: post.from }),
+                    ...(post.prompt === undefined ? {} : { prompt: post.prompt }),
+                    ...(post.author === undefined ? {} : { author: post.author }),
+                }),
+                ...[...post.history].sort((a, b) => b.version - a.version).map(historyMetaView),
+            ],
+        }
+        : {}),
+});
+const stateOrder = (mock) => (mock.states.length ? mock.states : [null]);
+// 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")
+            .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];
+    const inState = posts.filter((p) => p.state === first);
+    const pick = inState.find((p) => p.status === "accepted") ??
+        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: pick.version };
+}
+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),
+});
+// 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 = {}) => ({
+    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,
+    sessionId: mock.sessionId,
+    createdAt: mock.createdAt,
+    updatedAt: mock.updatedAt,
+    variants: posts.map((p) => variantView(p, opts)),
+    parts: partsByState(mock, posts),
+    // The knob values of the latest reply — what the user last sent, not drafts.
+    tuned: opts.tuned ?? {},
+});
+export const sessionRowView = (session, postCount) => ({
+    ...session,
+    postCount,
+});

package/dist/server/app.d.ts

@@ -0,0 +1,53 @@
+import { Hono } from "hono";
+import { type FeedEvent } from "./events.ts";
+import { type GuideTopic } from "./designGuide.ts";
+import { type Executor, type RunLimits } from "./run.ts";
+import { type Store } from "./types.ts";
+export type { FeedEvent } from "./events.ts";
+export type { FeedbackBatch } from "./feedbackBatch.ts";
+export type AuthenticateHook = (request: Request) => boolean | Response | Promise<boolean | Response>;
+export type BasePathHook = string | ((request: Request) => string | null | undefined);
+export type PublicReadMode = "session" | "full";
+export interface AppOptions {
+    store: Store;
+    viewerHtml: string;
+    setupText: string;
+    topics?: Partial<Record<GuideTopic, string>>;
+    authenticate?: AuthenticateHook;
+    authToken?: string;
+    basePath?: BasePathHook;
+    publicRead?: PublicReadMode;
+    screenshots?: boolean;
+    version?: string;
+    upgradeCommand?: string;
+    fetchLatestRelease?: () => Promise<LatestRelease | null>;
+    onEvent?: (event: FeedEvent) => void;
+    maxHoldConnections?: number;
+    executor?: Executor;
+    runLimits?: Partial<RunLimits>;
+}
+export interface LatestRelease {
+    version: string;
+    notes?: string;
+}
+export interface CommentWait {
+    sessionId?: string;
+    mockId?: string;
+    postId?: string;
+    author?: string;
+    afterSeq?: number;
+    waitSeconds: number;
+    agent?: boolean;
+}
+export interface FlowResult {
+    status: number;
+    body: any;
+}
+export interface FlowContext {
+    base: string;
+    viewer: boolean;
+    strict: boolean;
+    request?: Request;
+    signal?: AbortSignal;
+}
+export declare function createApp({ store, viewerHtml, setupText, topics, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;