@vincentt-xr/harness 0.4.0 → 1.1.0

package/README.md

@@ -1,87 +0,0 @@
-# @vincentt-xr/harness
-
-The Vincentt AR dev-loop harness. It is **one always-on diagnostics channel**
-between the AR app running on a phone and the coding agent running on a laptop,
-so the agent can see what the phone sees — console logs, network requests,
-performance — without the developer hand-ferrying DevTools traces or pasting
-console output.
-
-Agent-agnostic: the agent side is a plain **MCP server**, so any MCP-capable
-agent (Claude Code, Codex, Cursor, Cline, …) uses it the same way.
-
-## The three parts
-
-```
-  PHONE (preview app)          RELAY (laptop)         AGENT (laptop)
-  ┌──────────────────┐    ┌────────────────┐    ┌────────────────────┐
-  │ HarnessProvider  │    │  harness-relay │    │  harness-mcp       │
-  │ • patch console  │─ws→│  ring buffer   │←──→│  diag_logs         │
-  │ • wrap fetch/XHR │    │  per session   │http│  diag_network      │
-  │ • sample perf    │    │                │    │  diag_trace        │
-  └──────────────────┘    └────────────────┘    └────────────────────┘
-   src/client (npm pkg)      src/relay (bin)        src/mcp (bin)
-```
-
-- **`src/client`** — the in-app half; the published npm package. `HarnessProvider`
-  patches `console.*`, wraps `fetch`/`XHR`, and samples `performance`, shipping
-  events to the relay over a WebSocket. Auto-on in a dev build, no-op (and
-  tree-shaken) in production.
-- **`src/relay`** — a small WebSocket + HTTP server beside Vite. Holds a bounded
-  ring buffer of recent events per session. The phone pushes; the agent pulls.
-- **`src/mcp`** — the agent-agnostic MCP server. Exposes `diag_logs`,
-  `diag_network`, `diag_trace` that pull from the relay.
-
-- **`src/shared/events.ts`** — the wire contract all three import, so they can't
-  drift on the event shape.
-
-## Use it
-
-**In the app (once):**
-
-```tsx
-import { HarnessProvider } from "@vincentt-xr/harness";
-
-<HarnessProvider>
-  <App />
-</HarnessProvider>;
-```
-
-That's the whole author-facing surface. It self-activates in dev and disappears
-in the production build.
-
-**Run the relay** beside your dev server (the preview tunnel carries its socket
-to the phone):
-
-```
-npx harness-relay          # listens on :7331, ws path /__harness
-```
-
-**Point your agent at the MCP server.** In the agent's MCP config:
-
-```json
-{
-  "mcpServers": {
-    "vincentt-harness": { "command": "npx", "args": ["harness-mcp"] }
-  }
-}
-```
-
-Then, while the app is open on the phone, the agent calls `diag_logs`,
-`diag_network`, `diag_trace` to read what the device is doing — no DevTools, no
-copy-paste.
-
-## Develop
-
-```
-pnpm install
-pnpm test         # unit tests (pure event-shaping, buffer, ring store, formatting, fps)
-pnpm typecheck
-pnpm build        # emits dist/ (client = npm surface; relay/mcp = bins)
-```
-
-## Status
-
-Local-first. The diagnostics limb is built and proven end-to-end
-(phone → relay → agent). The platform lifecycle (per-project server-minted
-tunnels, `createProject`/`publish`, auth) is a separate later phase; the same
-client + relay also feed the production client-review service.

package/dist/cli/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli/index.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// `harness` — top-level CLI. Today it dispatches a single subcommand, `login`,
-// which obtains a Personal Access Token through the editor's /oauth flow and
-// writes it to ~/.vincentt/config.json (the MCP verbs then read it).
-import os from "node:os";
-import { runLogin } from "../login/login.js";
-const DEFAULT_EDITOR_URL = "https://editor.vincentt.studio";
-const DEFAULT_API_URL = "https://api.vincentt.studio";
-function flag(name) {
-    const i = process.argv.indexOf(name);
-    return i !== -1 ? process.argv[i + 1] : undefined;
-}
-function usage() {
-    console.log(`Usage: harness login [options]\n\n` +
-        `  Sign in and save a Vincentt access token to ~/.vincentt/config.json.\n\n` +
-        `Options:\n` +
-        `  --editor <url>  Editor base URL (default ${DEFAULT_EDITOR_URL}, or $VINCENTT_EDITOR_URL)\n` +
-        `  --api <url>     Backend API base URL (default ${DEFAULT_API_URL}, or $VINCENTT_API_URL)\n` +
-        `  --name <label>  Token label shown in the editor (default "Harness CLI (<host>)")\n`);
-}
-async function login() {
-    const editorUrl = flag("--editor") ?? process.env.VINCENTT_EDITOR_URL ?? DEFAULT_EDITOR_URL;
-    const apiUrl = flag("--api") ?? process.env.VINCENTT_API_URL ?? DEFAULT_API_URL;
-    const tokenName = flag("--name") ?? `Harness CLI (${os.hostname()})`;
-    console.log("Opening your browser to authorize this device…");
-    const { apiUrl: saved, configPath } = await runLogin({
-        editorUrl,
-        apiUrl,
-        tokenName,
-        onUrl: (url) => console.log(`\nIf your browser didn't open, visit:\n  ${url}\n`),
-    });
-    console.log(`\n✓ Signed in. Access token saved to ${configPath}`);
-    console.log(`  API: ${saved}`);
-}
-async function main() {
-    const cmd = process.argv[2];
-    switch (cmd) {
-        case "login":
-            await login();
-            break;
-        case undefined:
-        case "-h":
-        case "--help":
-            usage();
-            break;
-        default:
-            console.error(`Unknown command: ${cmd}\n`);
-            usage();
-            process.exitCode = 1;
-    }
-}
-main().catch((err) => {
-    console.error(`\n✗ ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-});

package/dist/login/login.d.ts

@@ -1,34 +0,0 @@
-export interface LoginOptions {
-    /** Editor base URL that serves the /oauth consent page. */
-    editorUrl: string;
-    /** Backend API base URL the minted PAT authenticates against (paired with editorUrl). */
-    apiUrl: string;
-    /** Human label stored with the token (shown in the editor's token list). */
-    tokenName: string;
-    /** Abort if the browser round-trip doesn't complete in time. Default 5 min. */
-    timeoutMs?: number;
-    /** Set false to skip launching a browser (tests / headless). Default true. */
-    openInBrowser?: boolean;
-    /** Called with the authorize URL once the listener is up (for a printable fallback). */
-    onUrl?: (url: string) => void;
-}
-/** Prefix a scheme when the user passed a bare host; localhost defaults to http. */
-export declare function normalizeBaseUrl(u: string): string;
-export declare function buildAuthorizeUrl(editorBase: string, redirectUri: string, state: string, tokenName: string): string;
-export type CallbackResult = {
-    ok: true;
-    token: string;
-} | {
-    ok: false;
-    message: string;
-};
-/** Interpret the editor's loopback redirect. State is verified first, always. */
-export declare function parseCallback(params: URLSearchParams, expectedState: string): CallbackResult;
-/**
- * Run the loopback OAuth round-trip and persist the resulting PAT. Resolves with
- * the apiUrl written to config; rejects on cancel, state mismatch, or timeout.
- */
-export declare function runLogin(opts: LoginOptions): Promise<{
-    apiUrl: string;
-    configPath: string;
-}>;

package/dist/login/login.js

@@ -1,148 +0,0 @@
-// `harness login` — obtain a Personal Access Token via the editor's /oauth flow.
-//
-// The CLI can't mint a PAT directly (POST /access-tokens is Cognito-only, so a
-// machine token can never mint another). Instead it delegates to the editor:
-//   1. Start a loopback HTTP listener on 127.0.0.1:<ephemeral port>.
-//   2. Open the browser to <editor>/oauth?redirect_uri=…&state=…&name=… — the
-//      editor reuses its own passwordless login + a consent screen and mints the
-//      PAT on the user's behalf.
-//   3. The editor redirects ?token=<vpat_…>&state=… back to the loopback.
-//   4. Verify state, write the PAT to ~/.vincentt/config.json.
-// The PAT crosses only over loopback on the user's own machine.
-import { spawn } from "node:child_process";
-import { createServer } from "node:http";
-import { randomBytes } from "node:crypto";
-import { getFreePort } from "../preview/net.js";
-import { writeMachineConfig } from "../shared/config.js";
-/** Prefix a scheme when the user passed a bare host; localhost defaults to http. */
-export function normalizeBaseUrl(u) {
-    if (/^https?:\/\//i.test(u))
-        return u;
-    const local = /^(localhost|127\.0\.0\.1)(:|\/|$)/i.test(u);
-    return `${local ? "http" : "https"}://${u}`;
-}
-export function buildAuthorizeUrl(editorBase, redirectUri, state, tokenName) {
-    const u = new URL("/oauth", normalizeBaseUrl(editorBase));
-    u.searchParams.set("redirect_uri", redirectUri);
-    u.searchParams.set("state", state);
-    u.searchParams.set("name", tokenName);
-    return u.toString();
-}
-/** Interpret the editor's loopback redirect. State is verified first, always. */
-export function parseCallback(params, expectedState) {
-    if (params.get("state") !== expectedState) {
-        return { ok: false, message: "State mismatch — ignoring an unexpected callback." };
-    }
-    const error = params.get("error");
-    if (error) {
-        return {
-            ok: false,
-            message: error === "access_denied" ? "Authorization was cancelled." : `Authorization failed: ${error}`,
-        };
-    }
-    const token = params.get("token");
-    if (!token)
-        return { ok: false, message: "No token in the authorization response." };
-    return { ok: true, token };
-}
-function escapeHtml(s) {
-    return s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
-}
-// Standalone success/failure page shown in the browser tab after the loopback
-// round-trip. Fully self-contained (inline CSS, no assets) since it's served off
-// the CLI's own listener; theme-aware to match the editor's sand/ink palette.
-function browserPage(ok, heading, body) {
-    const accent = ok ? "#16a34a" : "#dc2626";
-    const glyph = ok ? "&check;" : "&times;";
-    return `<!doctype html>
-<html lang="en"><head><meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1"><title>Vincentt XR</title>
-<style>
-  :root { color-scheme: light dark; }
-  * { box-sizing: border-box; }
-  body { margin:0; min-height:100vh; display:flex; align-items:center; justify-content:center;
-    font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;
-    background:#f4efe6; color:#1c1917; }
-  .card { width:min(92vw,380px); background:#fff; border:1px solid #e7e0d3; border-radius:16px;
-    padding:40px 36px; text-align:center; box-shadow:0 10px 40px rgba(0,0,0,.08); }
-  .brand { display:flex; align-items:center; justify-content:center; gap:8px; margin-bottom:26px;
-    font-weight:700; font-size:15px; letter-spacing:-.01em; }
-  .dot { width:26px; height:26px; border-radius:8px; background:linear-gradient(135deg,#7c3aed,#2563eb); }
-  .glyph { width:48px; height:48px; margin:0 auto 16px; border-radius:50%; color:#fff;
-    display:flex; align-items:center; justify-content:center; font-size:26px; line-height:1; background:${accent}; }
-  h1 { font-size:19px; margin:0 0 6px; }
-  p { font-size:13px; opacity:.7; margin:0; line-height:1.5; }
-  @media (prefers-color-scheme: dark) {
-    body { background:#1c1917; color:#f4efe6; }
-    .card { background:#292524; border-color:#3f3a36; }
-  }
-</style></head>
-<body><div class="card">
-  <div class="brand"><span class="dot"></span>Vincentt XR</div>
-  <div class="glyph">${glyph}</div>
-  <h1>${escapeHtml(heading)}</h1>
-  <p>${escapeHtml(body)}</p>
-</div></body></html>`;
-}
-function openBrowser(url) {
-    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
-    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-    try {
-        const child = spawn(cmd, args, { stdio: "ignore", detached: true });
-        child.on("error", () => { });
-        child.unref();
-    }
-    catch {
-        // Falls back to the printed URL (onUrl) — never fatal.
-    }
-}
-/**
- * Run the loopback OAuth round-trip and persist the resulting PAT. Resolves with
- * the apiUrl written to config; rejects on cancel, state mismatch, or timeout.
- */
-export async function runLogin(opts) {
-    const state = randomBytes(16).toString("hex");
-    const port = await getFreePort();
-    const redirectUri = `http://127.0.0.1:${port}/callback`;
-    const authorizeUrl = buildAuthorizeUrl(opts.editorUrl, redirectUri, state, opts.tokenName);
-    const token = await new Promise((resolve, reject) => {
-        const server = createServer((req, res) => {
-            const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
-            if (url.pathname !== "/callback") {
-                res.writeHead(404, { "content-type": "text/plain" });
-                res.end("Not found");
-                return;
-            }
-            const result = parseCallback(url.searchParams, state);
-            res.writeHead(result.ok ? 200 : 400, { "content-type": "text/html; charset=utf-8" });
-            res.end(result.ok
-                ? browserPage(true, "You're signed in", "You can close this tab and return to your terminal.")
-                : browserPage(false, "Sign-in failed", result.message));
-            // A state-mismatch response is answered but must NOT settle the flow — a
-            // stray/forged request shouldn't tear down the listener the real callback
-            // still needs.
-            if (result.ok) {
-                server.close();
-                resolve(result.token);
-            }
-            else if (url.searchParams.get("state") === state) {
-                server.close();
-                reject(new Error(result.message));
-            }
-        });
-        server.on("error", reject);
-        server.listen(port, "127.0.0.1", () => {
-            opts.onUrl?.(authorizeUrl);
-            if (opts.openInBrowser !== false)
-                openBrowser(authorizeUrl);
-        });
-        const timer = setTimeout(() => {
-            server.close();
-            reject(new Error("Timed out waiting for browser authorization."));
-        }, opts.timeoutMs ?? 5 * 60_000);
-        timer.unref();
-    });
-    const apiUrl = opts.apiUrl.replace(/\/$/, "");
-    const configPath = await writeMachineConfig({ apiUrl, pat: token });
-    return { apiUrl, configPath };
-}

package/dist/mcp/backend.d.ts

@@ -1,52 +0,0 @@
-import type { ResolvedConfig } from "../shared/config.js";
-export interface CreatedProject {
-    projectId: string;
-    slug: string;
-    name: string;
-}
-export interface PublishResult {
-    version: number;
-    /** Immutable versioned URL (<slug>.<apex>/v<n>/). */
-    url: string;
-    /** Stable live alias (<slug>.<apex>/). */
-    liveUrl: string;
-}
-export declare class BackendError extends Error {
-    readonly status?: number | undefined;
-    constructor(message: string, status?: number | undefined);
-}
-/**
- * Create a backend project (reuses POST /projects). A `slug` pins the permanent
- * <slug>.vincentt.app host; omit it and the platform assigns a catchy one. A
- * taken slug comes back 409, surfaced so the caller can re-ask.
- */
-export declare function createProject(cfg: ResolvedConfig, name: string, slug?: string): Promise<CreatedProject>;
-export interface MintedTunnel {
-    tunnelId: string;
-    /** The public host the phone opens: <slug>-<token>.<previewApex>. */
-    hostname: string;
-    /** cloudflared run token — `cloudflared tunnel run --token <this>`. */
-    runToken: string;
-    /** DNS record id, passed back on reap. */
-    dnsRecordId: string;
-}
-/** Mint a per-session dev tunnel for `localPort` (the backend holds CF creds). */
-export declare function mintTunnel(cfg: ResolvedConfig, projectId: string, localPort: number): Promise<MintedTunnel>;
-/** Tear down a session tunnel (DNS route + tunnel). Best-effort; never throws. */
-export declare function reapTunnel(cfg: ResolvedConfig, projectId: string, ref: {
-    tunnelId: string;
-    dnsRecordId?: string;
-}): Promise<void>;
-/** Recursively list files under `dir`, returning dir-relative POSIX paths. */
-export declare function walkDir(dir: string, base?: string): Promise<string[]>;
-/**
- * Upload a locally-built dist and make it live. Each file rides as a multipart
- * part whose filename is its dist-relative path (the backend reconstructs the
- * tree). Requires an index.html at the dist root.
- */
-export declare function publishUpload(cfg: ResolvedConfig, projectId: string, distDir: string, opts?: {
-    note?: string;
-    commitSha?: string;
-}): Promise<PublishResult>;
-/** The working tree's current commit, for publish provenance. Undefined if not a repo. */
-export declare function gitHeadSha(cwd: string): Promise<string | undefined>;

package/dist/mcp/backend.js

@@ -1,146 +0,0 @@
-// The lifecycle verbs' backend calls, isolated from the MCP SDK wiring (server.ts)
-// so they're unit-testable and the transport can change without touching them.
-// Every call is PAT-authed (Bearer). The publish path uploads an already-built
-// dist as-is — the backend never rebuilds (Principle 0).
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-export class BackendError extends Error {
-    status;
-    constructor(message, status) {
-        super(message);
-        this.status = status;
-        this.name = "BackendError";
-    }
-}
-async function authFetch(cfg, pathname, init = {}) {
-    return fetch(`${cfg.apiUrl}${pathname}`, {
-        ...init,
-        headers: { ...(init.headers ?? {}), authorization: `Bearer ${cfg.pat}` },
-    });
-}
-async function safeText(res) {
-    try {
-        return (await res.text()).slice(0, 300);
-    }
-    catch {
-        return "";
-    }
-}
-/**
- * Create a backend project (reuses POST /projects). A `slug` pins the permanent
- * <slug>.vincentt.app host; omit it and the platform assigns a catchy one. A
- * taken slug comes back 409, surfaced so the caller can re-ask.
- */
-export async function createProject(cfg, name, slug) {
-    const res = await authFetch(cfg, "/projects", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ name, ...(slug ? { slug } : {}) }),
-    });
-    if (res.status === 409) {
-        throw new BackendError(`slug "${slug}" is already in use — pick another.`, 409);
-    }
-    if (!res.ok) {
-        throw new BackendError(`create project failed (${res.status}): ${await safeText(res)}`, res.status);
-    }
-    const p = (await res.json());
-    const projectId = p._id ?? p.id;
-    if (!projectId || !p.slug) {
-        throw new BackendError("create project: response missing id/slug");
-    }
-    return { projectId, slug: p.slug, name: p.name ?? name };
-}
-/** Mint a per-session dev tunnel for `localPort` (the backend holds CF creds). */
-export async function mintTunnel(cfg, projectId, localPort) {
-    const res = await authFetch(cfg, `/projects/${projectId}/tunnel`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ port: localPort }),
-    });
-    if (!res.ok) {
-        throw new BackendError(`tunnel mint failed (${res.status}): ${await safeText(res)}`, res.status);
-    }
-    return (await res.json());
-}
-/** Tear down a session tunnel (DNS route + tunnel). Best-effort; never throws. */
-export async function reapTunnel(cfg, projectId, ref) {
-    try {
-        await authFetch(cfg, `/projects/${projectId}/tunnel/reap`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(ref),
-        });
-    }
-    catch {
-        // Reap is a cleanup courtesy — a failure must never crash the preview teardown.
-    }
-}
-/** Recursively list files under `dir`, returning dir-relative POSIX paths. */
-export async function walkDir(dir, base = dir) {
-    const out = [];
-    let entries;
-    try {
-        entries = await fs.readdir(dir, { withFileTypes: true });
-    }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            throw new BackendError(`dist directory not found: ${dir}`);
-        }
-        throw err;
-    }
-    for (const entry of entries) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...(await walkDir(full, base)));
-        else if (entry.isFile())
-            out.push(path.relative(base, full).split(path.sep).join("/"));
-    }
-    return out;
-}
-/**
- * Upload a locally-built dist and make it live. Each file rides as a multipart
- * part whose filename is its dist-relative path (the backend reconstructs the
- * tree). Requires an index.html at the dist root.
- */
-export async function publishUpload(cfg, projectId, distDir, opts = {}) {
-    const files = await walkDir(distDir);
-    if (!files.includes("index.html")) {
-        throw new BackendError(`dist at ${distDir} has no index.html at its root — did the build run?`);
-    }
-    const form = new FormData();
-    // The real dist-relative paths ride as an ordered manifest — a multipart filename
-    // can't carry a directory (FormData strips it to a basename), so the backend maps
-    // paths[i] → files[i] to rebuild the tree.
-    form.append("paths", JSON.stringify(files));
-    for (const rel of files) {
-        const bytes = await fs.readFile(path.join(distDir, rel));
-        // Uint8Array (Buffer) is a valid BlobPart; the filename is cosmetic (the backend
-        // uses the manifest), but pass the basename so server logs read sensibly.
-        form.append("files", new Blob([bytes]), path.basename(rel));
-    }
-    if (opts.note)
-        form.append("note", opts.note);
-    if (opts.commitSha)
-        form.append("commitSha", opts.commitSha);
-    const res = await authFetch(cfg, `/projects/${projectId}/publish/upload`, {
-        method: "POST",
-        body: form,
-    });
-    if (!res.ok) {
-        throw new BackendError(`publish failed (${res.status}): ${await safeText(res)}`, res.status);
-    }
-    return (await res.json());
-}
-/** The working tree's current commit, for publish provenance. Undefined if not a repo. */
-export async function gitHeadSha(cwd) {
-    try {
-        const { stdout } = await execFileAsync("git", ["-C", cwd, "rev-parse", "HEAD"]);
-        return stdout.trim();
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/mcp/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/mcp/cli.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// `harness-mcp` — the agent-side MCP server. An MCP agent spawns this over
-// stdio. Point it at a non-default relay with --relay-url.
-import { runStdio } from "./server.js";
-const urlArg = process.argv.indexOf("--relay-url");
-const relayUrl = urlArg !== -1 ? process.argv[urlArg + 1] : undefined;
-runStdio({ relayUrl }).catch((err) => {
-    console.error("[harness-mcp] fatal:", err);
-    process.exit(1);
-});

package/dist/mcp/diagnostics.d.ts

@@ -1,13 +0,0 @@
-import type { DiagEvent, LogEvent, NetworkEvent, RelayQuery, RelayResult, TraceEvent } from "../shared/events.js";
-export interface RelayClient {
-    query(q: RelayQuery): Promise<RelayResult>;
-}
-/** A RelayClient backed by the relay's HTTP /query endpoint. */
-export declare function httpRelayClient(baseUrl: string): RelayClient;
-export declare function formatLog(e: LogEvent, now: number): string;
-export declare function formatNetwork(e: NetworkEvent, now: number): string;
-export declare function formatTrace(e: TraceEvent, now: number): string;
-/** Render a RelayResult for one kind into the text block a tool returns. */
-export declare function renderResult(result: RelayResult, kind: DiagEvent["kind"], now: number): string;
-/** Only-errors convenience filter applied on top of a log query result. */
-export declare function filterErrors(result: RelayResult): RelayResult;

package/dist/mcp/diagnostics.js

@@ -1,61 +0,0 @@
-// The MCP server's logic, independent of the MCP SDK surface: fetch events from
-// the relay and format them into the compact text an agent reads. Kept separate
-// from the SDK wiring (server.ts) so the formatting is unit-testable and the SDK
-// version can churn without touching this.
-/** A RelayClient backed by the relay's HTTP /query endpoint. */
-export function httpRelayClient(baseUrl) {
-    return {
-        async query(q) {
-            const res = await fetch(`${baseUrl}/query`, {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify(q),
-            });
-            if (!res.ok)
-                throw new Error(`relay /query returned ${res.status}`);
-            return (await res.json());
-        },
-    };
-}
-/** Human-time from the client timestamp, relative to now, for the agent's read. */
-function ago(t, now) {
-    const s = Math.max(0, Math.round((now - t) / 1000));
-    return s < 60 ? `${s}s ago` : `${Math.round(s / 60)}m ago`;
-}
-export function formatLog(e, now) {
-    const level = e.level.toUpperCase().padEnd(5);
-    const origin = e.origin ? `  (${e.origin})` : "";
-    return `[${level}] ${e.message}${origin}  · ${ago(e.t, now)} #${e.seq}`;
-}
-export function formatNetwork(e, now) {
-    const status = e.error ? `ERR ${e.error}` : String(e.status);
-    return `${e.method} ${e.url} → ${status} (${e.durationMs}ms)  · ${ago(e.t, now)} #${e.seq}`;
-}
-export function formatTrace(e, now) {
-    const marks = e.marks.length ? `  marks: ${e.marks.join(", ")}` : "";
-    return (`${e.fps.toFixed(0)}fps over ${e.windowMs}ms · longest task ${e.longestTaskMs}ms · ` +
-        `${e.longTaskCount} long task(s)${marks}  · ${ago(e.t, now)} #${e.seq}`);
-}
-/** Render a RelayResult for one kind into the text block a tool returns. */
-export function renderResult(result, kind, now) {
-    const lines = result.events.map((e) => {
-        if (e.kind === "log")
-            return formatLog(e, now);
-        if (e.kind === "network")
-            return formatNetwork(e, now);
-        return formatTrace(e, now);
-    });
-    const header = result.sessions.length > 1 ? `sessions: ${result.sessions.join(", ")}\n` : "";
-    const cursor = `\n\n(latestSeq ${result.latestSeq} — pass since=${result.latestSeq} to get only newer ${kind} events)`;
-    if (lines.length === 0) {
-        return `${header}No ${kind} events${result.latestSeq >= 0 ? " matched" : " yet — is the preview app open on the device?"}.${result.latestSeq >= 0 ? cursor : ""}`;
-    }
-    return `${header}${lines.join("\n")}${cursor}`;
-}
-/** Only-errors convenience filter applied on top of a log query result. */
-export function filterErrors(result) {
-    return {
-        ...result,
-        events: result.events.filter((e) => e.kind === "log" && e.level === "error"),
-    };
-}

package/dist/mcp/server.d.ts

@@ -1,16 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type RelayClient } from "./diagnostics.js";
-/** Reap the running preview, if any. Called by preview_stop and on server exit. */
-export declare function shutdownActivePreview(): Promise<void>;
-export interface McpOptions {
-    /** Base URL of the relay's HTTP endpoint (default matches the relay CLI). */
-    relayUrl?: string;
-    /** Injected for tests; defaults to an HTTP client against relayUrl. */
-    relay?: RelayClient;
-    /** Injected clock for deterministic relative-time rendering in tests. */
-    now?: () => number;
-    /** Project directory for the lifecycle verbs' binding. Defaults to process.cwd(). */
-    cwd?: string;
-}
-export declare function createHarnessMcp(opts?: McpOptions): McpServer;
-export declare function runStdio(opts?: McpOptions): Promise<void>;