@pro-vi/designer 0.3.9 → 0.3.11

package/dist/mcp-server.js

@@ -32,7 +32,7 @@ server.registerTool('designer_session', {
     }
 }, async ({ key, action = 'status', name, fidelity }) => textResult(await getController(key).session({ action, name, fidelity })));
 server.registerTool('designer_prompt', {
-    description: "Modify the design. Sends a prompt you expect to change the served HTML (e.g., 'create a login screen', 'add a Remember-me checkbox'). Waits for HTML to change and stabilize. Returns slim metadata — NOT inline HTML (written to disk at htmlPath).\n\n**Default taste path: hand the human `url` from the return.** The URL is the live claude.ai/design surface — fully interactive, tweak sliders work, variant switcher works. Only reach for `designer tasting` when full-viewport comparison matters more than interactivity.\n\nAuto-appended to every prompt: an instruction to keep all generated files at the project root (no subfolders). The live MCP's file-list scrape is flat-only; subfolder-nested files are invisible until `designer_handoff`. If you need nested layouts, explicitly contradict this in your prompt.\n\nKey return fields:\n- url: live URL to show the human (default taste path)\n- done.failureMode: null | 'timeout' | 'unstable' | 'no_change' (no_change means Claude replied text-only — did you want designer_ask?)\n- newFiles / removedFiles: diff vs pre-send\n- activeFile: what's currently rendered\n- htmlPath / screenshotPath: read these only if you need the content\n- chatReply: Claude's commentary",
+    description: "Modify the design. Sends a prompt you expect to change the served HTML (e.g., 'create a login screen', 'add a Remember-me checkbox'). Waits for Claude Design's turn-RPC completion signal, then fetches the served HTML once it settles; if the network observer is unavailable, falls back to the older HTML-stability wait. Returns slim metadata — NOT inline HTML (written to disk at htmlPath).\n\n**Default taste path: hand the human `url` from the return.** The URL is the live claude.ai/design surface — fully interactive, tweak sliders work, variant switcher works. Only reach for `designer tasting` when full-viewport comparison matters more than interactivity.\n\nAuto-appended to every prompt: an instruction to keep all generated files at the project root (no subfolders). The live MCP's file-list scrape is flat-only; subfolder-nested files are invisible until `designer_handoff`. If you need nested layouts, explicitly contradict this in your prompt.\n\nKey return fields:\n- url: live URL to show the human (default taste path)\n- done.failureMode: null | 'timeout' | 'unstable' | 'no_change' | 'stalled' | 'blocked' (no_change now reliably means Claude finished without changing served HTML, often a chat-only reply; stalled means turn RPCs went silent until the hard timeout; blocked means a critical turn RPC failed)\n- newFiles / removedFiles: diff vs pre-send\n- activeFile: what's currently rendered\n- htmlPath / screenshotPath: read these only if you need the content\n- chatReply: Claude's commentary",
     inputSchema: {
         key: z.string().optional(),
         prompt: z.string(),

package/dist/run-state.js

@@ -0,0 +1,327 @@
+import { CdpSession } from "./cdp-trace.js";
+export const OMELETTE_TURN_SERVICE = 'anthropic.omelette.api.v1alpha.OmeletteService';
+export const TURN_RPCS = ['Chat', 'RenewTurn', 'ReleaseTurn'];
+function asRec(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+function num(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+function eventWallMs(params) {
+    const syntheticTraceTs = num(params.ts);
+    if (syntheticTraceTs !== null)
+        return syntheticTraceTs;
+    const wallTime = num(params.wallTime);
+    return wallTime !== null ? wallTime * 1000 : null;
+}
+function requestId(params) {
+    return typeof params.requestId === 'string' ? params.requestId : undefined;
+}
+export function turnRpcFromUrl(url) {
+    if (!url)
+        return null;
+    let path = url;
+    try {
+        path = new URL(url).pathname;
+    }
+    catch {
+    }
+    const escapedService = OMELETTE_TURN_SERVICE.replace(/\./g, '\\.');
+    const match = path.match(new RegExp(`(?:^|/)${escapedService}/(Chat|RenewTurn|ReleaseTurn)(?:$|[/?#])`));
+    if (!match?.[1])
+        return null;
+    return TURN_RPCS.includes(match[1]) ? match[1] : null;
+}
+export function observedRpcPathFromUrl(url) {
+    if (!url)
+        return null;
+    let path = url;
+    try {
+        path = new URL(url).pathname;
+    }
+    catch {
+    }
+    const serviceIdx = path.indexOf(`${OMELETTE_TURN_SERVICE}/`);
+    if (serviceIdx >= 0)
+        return path.slice(serviceIdx);
+    const idx = path.indexOf('OmeletteService/');
+    return idx >= 0 ? path.slice(idx) : null;
+}
+export function isTurnRpcUrl(url) {
+    return turnRpcFromUrl(url) !== null;
+}
+function urlFromParams(method, params) {
+    if (typeof params.requestUrl === 'string')
+        return params.requestUrl;
+    if (typeof params.url === 'string')
+        return params.url;
+    if (method === 'Network.requestWillBeSent') {
+        const req = asRec(params.request);
+        return typeof req.url === 'string' ? req.url : '';
+    }
+    if (method === 'Network.responseReceived') {
+        const resp = asRec(params.response);
+        return typeof resp.url === 'string' ? resp.url : '';
+    }
+    return '';
+}
+function isCriticalRpc(rpc) {
+    return rpc === 'Chat' || rpc === 'RenewTurn';
+}
+export function classifyEvent(method, rawParams, runStartTs) {
+    const params = asRec(rawParams);
+    const wallMs = eventWallMs(params);
+    if (wallMs !== null && wallMs < runStartTs)
+        return null;
+    const url = urlFromParams(method, params);
+    const rpc = turnRpcFromUrl(url);
+    if (method === 'Network.requestWillBeSent') {
+        if (rpc === 'Chat')
+            return { kind: 'chat-open', requestId: requestId(params) };
+        if (rpc === 'RenewTurn')
+            return { kind: 'heartbeat', requestId: requestId(params) };
+        if (rpc === 'ReleaseTurn')
+            return { kind: 'release', requestId: requestId(params) };
+        return null;
+    }
+    if (method === 'Network.dataReceived' && rpc === 'Chat') {
+        return { kind: 'chat-chunk', requestId: requestId(params) };
+    }
+    if (method === 'Network.responseReceived') {
+        const response = asRec(params.response);
+        const status = num(response.status);
+        if (status !== null && status >= 400 && isCriticalRpc(rpc)) {
+            return { kind: 'critical-error', rpc, status };
+        }
+        return null;
+    }
+    if (method === 'Network.loadingFailed' && isCriticalRpc(rpc)) {
+        return { kind: 'critical-error', rpc, status: 'failed' };
+    }
+    return null;
+}
+export class RunStateObserver extends CdpSession {
+    now;
+    currentState = 'idle';
+    runStartTs = 0;
+    lastActivity = 0;
+    priorRunSignals = 0;
+    terminalResult = null;
+    watchdog = null;
+    waiters = [];
+    requestUrls = new Map();
+    observedRpcPaths = new Set();
+    signalCounts = {
+        chatOpen: 0,
+        chatChunk: 0,
+        heartbeat: 0,
+        release: 0,
+        criticalError: 0,
+        observerLost: 0
+    };
+    closeCount = 0;
+    constructor(ws, target, opts = {}) {
+        super(ws, target, opts);
+        this.now = opts.now ?? (() => Date.now());
+    }
+    static async attach(opts = {}) {
+        if (typeof WebSocket === 'undefined')
+            return null;
+        try {
+            const { ws, target } = await RunStateObserver.connectTarget(opts);
+            const observer = new RunStateObserver(ws, target, opts);
+            await observer.start();
+            return observer;
+        }
+        catch {
+            return null;
+        }
+    }
+    async start() {
+        await this.enableDomains();
+    }
+    beginRun() {
+        if (this.terminalResult)
+            return;
+        this.runStartTs = this.now();
+        this.lastActivity = this.runStartTs;
+        this.priorRunSignals = 0;
+        this.requestUrls.clear();
+        this.observedRpcPaths.clear();
+        this.resetSignalCounts();
+        this.currentState = 'running';
+    }
+    get state() {
+        if (this.terminalResult)
+            return this.terminalResult.terminal;
+        return this.currentState;
+    }
+    awaitTerminal({ stallMs = 25_000, hardTimeoutMs = 20 * 60_000 } = {}) {
+        if (this.terminalResult)
+            return Promise.resolve(this.terminalResult);
+        this.armWatchdog(stallMs, hardTimeoutMs);
+        this.checkSilence(stallMs, hardTimeoutMs);
+        if (this.terminalResult)
+            return Promise.resolve(this.terminalResult);
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    close() {
+        this.clearWatchdog();
+        if (this.closeSocket())
+            this.closeCount++;
+    }
+    signalSummary() {
+        return {
+            ...this.signalCounts,
+            observedRpcPaths: [...this.observedRpcPaths].sort()
+        };
+    }
+    closeCountForTest() {
+        return this.closeCount;
+    }
+    consumeSignalForTest(signal) {
+        this.consumeSignal(signal);
+    }
+    socketGapForTest(detail = { reason: 'test' }) {
+        this.onSocketGap(detail);
+    }
+    tickForTest({ stallMs = 25_000, hardTimeoutMs = 20 * 60_000 } = {}) {
+        this.checkSilence(stallMs, hardTimeoutMs);
+    }
+    onEvent(method, rawParams, _sessionId) {
+        if (this.currentState === 'idle' && !this.terminalResult)
+            return;
+        const params = this.enrichParams(method, rawParams);
+        if (method === 'Network.responseReceived' || method === 'Network.loadingFailed') {
+            const id = requestId(params);
+            if (!id || !this.requestUrls.has(id))
+                return;
+        }
+        const signal = classifyEvent(method, params, this.runStartTs);
+        if (signal)
+            this.consumeSignal(signal);
+    }
+    onSocketGap(_detail) {
+        if (this.currentState === 'running' || this.currentState === 'stalled') {
+            this.consumeSignal({ kind: 'observer-lost' });
+        }
+    }
+    onSocketReconnectFailed() {
+        this.consumeSignal({ kind: 'observer-lost' });
+    }
+    enrichParams(method, rawParams) {
+        const params = { ...asRec(rawParams) };
+        const id = requestId(params);
+        if (method === 'Network.requestWillBeSent' && id) {
+            const wallMs = eventWallMs(params);
+            if (wallMs !== null && wallMs < this.runStartTs)
+                return params;
+            const req = asRec(params.request);
+            const url = typeof req.url === 'string' ? req.url : '';
+            if (url) {
+                this.requestUrls.set(id, url);
+                const rpcPath = observedRpcPathFromUrl(url);
+                if (rpcPath)
+                    this.observedRpcPaths.add(rpcPath);
+            }
+        }
+        else if (id && !params.requestUrl) {
+            const url = this.requestUrls.get(id);
+            if (url)
+                params.requestUrl = url;
+        }
+        return params;
+    }
+    consumeSignal(signal) {
+        if (this.terminalResult)
+            return;
+        this.countSignal(signal);
+        if (signal.kind === 'observer-lost') {
+            this.latch('observer-lost');
+            return;
+        }
+        if (this.currentState === 'idle')
+            return;
+        if (signal.kind === 'chat-open' || signal.kind === 'chat-chunk' || signal.kind === 'heartbeat') {
+            this.lastActivity = this.now();
+            this.priorRunSignals++;
+            this.currentState = 'running';
+            return;
+        }
+        if (signal.kind === 'release') {
+            if (this.priorRunSignals === 0)
+                return;
+            this.latch('finished');
+            return;
+        }
+        if (signal.kind === 'critical-error') {
+            this.latch('blocked', `${signal.rpc} ${signal.status === 'failed' ? 'failed' : `HTTP ${signal.status}`}`);
+        }
+    }
+    countSignal(signal) {
+        if (signal.kind === 'chat-open')
+            this.signalCounts.chatOpen++;
+        else if (signal.kind === 'chat-chunk')
+            this.signalCounts.chatChunk++;
+        else if (signal.kind === 'heartbeat')
+            this.signalCounts.heartbeat++;
+        else if (signal.kind === 'release')
+            this.signalCounts.release++;
+        else if (signal.kind === 'critical-error')
+            this.signalCounts.criticalError++;
+        else if (signal.kind === 'observer-lost')
+            this.signalCounts.observerLost++;
+    }
+    resetSignalCounts() {
+        this.signalCounts.chatOpen = 0;
+        this.signalCounts.chatChunk = 0;
+        this.signalCounts.heartbeat = 0;
+        this.signalCounts.release = 0;
+        this.signalCounts.criticalError = 0;
+        this.signalCounts.observerLost = 0;
+    }
+    checkSilence(stallMs, hardTimeoutMs) {
+        if (this.terminalResult || this.currentState === 'idle')
+            return;
+        const now = this.now();
+        const silence = now - this.lastActivity;
+        const elapsed = now - this.runStartTs;
+        if (silence > hardTimeoutMs) {
+            this.latch('timeout', `silent for ${silence}ms`);
+        }
+        else if (elapsed > hardTimeoutMs) {
+            this.latch('timeout', `exceeded ${hardTimeoutMs}ms wall-clock budget (elapsed ${elapsed}ms)`);
+        }
+        else if (silence > stallMs) {
+            this.currentState = 'stalled';
+        }
+    }
+    armWatchdog(stallMs, hardTimeoutMs) {
+        if (this.watchdog)
+            return;
+        const intervalMs = Math.max(250, Math.min(1000, stallMs, hardTimeoutMs));
+        this.watchdog = setInterval(() => this.checkSilence(stallMs, hardTimeoutMs), intervalMs);
+    }
+    clearWatchdog() {
+        if (!this.watchdog)
+            return;
+        clearInterval(this.watchdog);
+        this.watchdog = null;
+    }
+    latch(terminal, reason) {
+        if (this.terminalResult)
+            return;
+        this.terminalResult = {
+            terminal,
+            elapsedMs: this.runStartTs === 0 ? 0 : Math.max(0, this.now() - this.runStartTs),
+            ...(reason ? { reason } : {})
+        };
+        this.clearWatchdog();
+        this.close();
+        const waiters = this.waiters.splice(0);
+        for (const resolve of waiters)
+            resolve(this.terminalResult);
+    }
+}

package/dist/scripts/ci-health.js

@@ -217,6 +217,7 @@ async function main() {
             sessionNav = { target: probeUrl, landedOn: '', error: e.message };
             console.log(`[ci-health] canary navigation failed — ${e.message}; session anchors will fail loudly`);
         }
+        process.env.DESIGNER_TURN_RPC_CANARY ??= '1';
         sessionResults = await runHealth(browser, { phase: 'session' });
     }
     else {