@lensmcp/nx-plugin 1.0.0

package/executors/agent-dev/agent-dev.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = agentDevExecutor;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * `agent-dev` — long-running executor that spawns:
+ *
+ *   1. The host project's Vite dev server (with `@lensmcp/vite-plugin`
+ *      already wired by `setup-vite`).
+ *   2. (Optional) a Chrome sidecar pointed at the dev URL so CDP
+ *      collectors see what the user sees.
+ *   3. The LensMCP MCP server, so an agent can connect.
+ *
+ * Phase 1 keeps this minimal: spawn-and-supervise, no clever
+ * inter-process correlation. The real session-supervisor coordinator
+ * lands in Phase 2/3 as `@lensmcp/session` extensions.
+ *
+ * Streams everyone's stdio to this terminal so the developer can see
+ * what's happening. Ctrl-C triggers a clean teardown.
+ */
+async function agentDevExecutor(options, context) {
+    const opts = {
+        kind: options.kind ?? 'vite-react',
+        chrome: options.chrome ?? true,
+        headless: options.headless ?? true,
+        devTarget: options.devTarget,
+        projectRoot: options.projectRoot,
+        port: options.port,
+        openUrl: options.openUrl,
+    };
+    if (opts.kind !== 'vite-react' && opts.kind !== 'nestjs') {
+        console.error(`[agent-dev] Phase 3 supports kind="vite-react" or "nestjs" (got "${opts.kind}").`);
+        return { success: false };
+    }
+    const project = context.projectName;
+    const projectRoot = opts.projectRoot
+        ? (0, node_path_1.resolve)(context.root, opts.projectRoot)
+        : project && context.projectsConfigurations
+            ? (0, node_path_1.resolve)(context.root, context.projectsConfigurations.projects[project]?.root ?? '.')
+            : context.root;
+    // ---- NestJS branch ----
+    if (opts.kind === 'nestjs') {
+        return runNestjs(projectRoot, context);
+    }
+    // ---- Vite/React branch (Phase 1) ----
+    const viteBin = locateBin('vite', [projectRoot, context.root]);
+    if (!viteBin) {
+        console.error('[agent-dev] Could not find vite binary in node_modules/.bin.');
+        return { success: false };
+    }
+    // Pin the dev port so the browser-capture driver knows the URL. When
+    // Chrome capture is on we always fix it (strictPort) so the attach
+    // target is deterministic.
+    const devPort = opts.port ?? (opts.chrome ? 5173 : undefined);
+    const viteArgs = [
+        '--config',
+        resolveFirstExisting(['vite.config.ts', 'vite.config.mts', 'vite.config.js', 'vite.config.mjs', 'vite.config.cts', 'vite.config.cjs'], projectRoot) ?? (0, node_path_1.join)(projectRoot, 'vite.config.ts'),
+        projectRoot,
+    ];
+    if (devPort !== undefined) {
+        viteArgs.push('--port', String(devPort), '--strictPort');
+    }
+    // 2. LensMCP MCP — prebuilt bundle from `apps/lensmcp-mcp/dist/main.js`.
+    //    In a host workspace post-`lensmcp install`, this is the bundled
+    //    CLI binary that ships with `lensmcp`. For dev in-repo we
+    //    locate the workspace's own build artefact.
+    const mcpBundle = findMcpBundle(context.root);
+    if (!mcpBundle) {
+        console.warn('[agent-dev] No lensmcp-mcp bundle found — skipping MCP server.');
+    }
+    const children = [];
+    const respawnCounts = new Map();
+    let exitRequested = false;
+    function spawnChild(label, bin, args, env, optional = false, respawn) {
+        const child = (0, node_child_process_1.spawn)(bin, args, {
+            cwd: projectRoot,
+            env: { ...process.env, ...(env ?? {}) },
+            stdio: 'inherit',
+        });
+        children.push(child);
+        child.on('exit', (code, sig) => {
+            if (exitRequested)
+                return;
+            if (optional) {
+                // Best-effort children (e.g. browser capture) may exit on their
+                // own (no Chrome, page closed) without tearing down the session.
+                // With a respawn policy they come back — a killed/crashed Chrome
+                // otherwise silently ends visual capture for the whole session.
+                const used = respawnCounts.get(label) ?? 0;
+                if (respawn && used < respawn.max) {
+                    respawnCounts.set(label, used + 1);
+                    console.warn(`[agent-dev] ${label} exited (code=${code} sig=${sig}); respawning in ${Math.round(respawn.delayMs / 1000)}s (${used + 1}/${respawn.max}).`);
+                    const t = setTimeout(() => {
+                        if (!exitRequested)
+                            spawnChild(label, bin, args, env, optional, respawn);
+                    }, respawn.delayMs);
+                    t.unref?.();
+                    return;
+                }
+                console.warn(`[agent-dev] ${label} exited (code=${code} sig=${sig}); continuing.`);
+                return;
+            }
+            console.warn(`[agent-dev] ${label} exited unexpectedly (code=${code} sig=${sig}); shutting down others.`);
+            shutdown();
+        });
+        return child;
+    }
+    function shutdown() {
+        if (exitRequested)
+            return;
+        exitRequested = true;
+        for (const c of children) {
+            try {
+                c.kill('SIGTERM');
+            }
+            catch { /* swallow */ }
+        }
+    }
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    // Cross-process event bridge: the Vite plugin (in the dev-server child)
+    // and the MCP server (in its own child) rendezvous on a shared JSONL
+    // event file. The plugin appends browser events; the server tails it
+    // via `startEventIngest`. Truncate it on start so a fresh run doesn't
+    // replay a previous session's events.
+    const eventFile = process.env['LENSMCP_EVENT_FILE'] ?? (0, node_path_1.join)(context.root, '.lensmcp', 'events.jsonl');
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(eventFile), { recursive: true });
+        // Truncate ONLY a stale file: another producer (e.g. the instrumented API in
+        // its own agent-dev) may be mid-session on the same bridge — wiping its
+        // events would blind every reader. "Active" = modified in the last 60s.
+        const st = (0, node_fs_1.statSync)(eventFile, { throwIfNoEntry: false });
+        if (!st || Date.now() - st.mtimeMs > 60_000) {
+            (0, node_fs_1.writeFileSync)(eventFile, '');
+        }
+        else {
+            console.log('[agent-dev] event bridge is active (written <60s ago) — appending, not truncating.');
+        }
+    }
+    catch {
+        /* non-fatal — ingest tolerates a missing file */
+    }
+    const bridgeEnv = { LENSMCP_EVENT_FILE: eventFile };
+    console.log(`[agent-dev] event bridge → ${eventFile}`);
+    console.log(`[agent-dev] starting Vite for ${project ?? projectRoot}`);
+    spawnChild('vite', viteBin, viteArgs, bridgeEnv);
+    if (mcpBundle) {
+        console.log(`[agent-dev] starting LensMCP MCP server (${mcpBundle})`);
+        spawnChild('lensmcp-mcp', process.execPath, [mcpBundle], {
+            ...bridgeEnv,
+            LENSMCP_TRANSPORT: process.env['LENSMCP_TRANSPORT'] ?? 'http',
+            LENSMCP_PORT: process.env['LENSMCP_PORT'] ?? '3000',
+        });
+    }
+    if (opts.chrome) {
+        // Live browser capture: launch a headless Chrome against the dev
+        // URL, forward real console/network/exception events + DOMSnapshot
+        // visual frames into the shared event file (best-effort — skips
+        // cleanly if no Chrome). Spawned as an optional child so its exit
+        // never tears down Vite/MCP.
+        const captureRunner = findCaptureRunner(context.root);
+        const devUrl = opts.openUrl ?? (devPort ? `http://localhost:${devPort}/` : undefined);
+        if (!captureRunner) {
+            console.warn('[agent-dev] browser-capture runner not built — skipping live capture.');
+        }
+        else if (!devUrl) {
+            console.warn('[agent-dev] no dev URL/port resolved — skipping live capture.');
+        }
+        else {
+            console.log(`[agent-dev] starting browser capture → ${devUrl}`);
+            spawnChild('browser-capture', process.execPath, [captureRunner], {
+                ...bridgeEnv,
+                LENSMCP_DEV_URL: devUrl,
+                LENSMCP_TOKENS_FILE: (0, node_path_1.join)(context.root, 'lensmcp.tokens.json'),
+                LENSMCP_RULES_FILE: (0, node_path_1.join)(context.root, 'lensmcp.rules.json'),
+                LENSMCP_HEADLESS: opts.headless === false ? 'false' : 'true',
+            }, true, // optional
+            { delayMs: 10_000, max: 5 });
+        }
+    }
+    // Wait until any child exits.
+    return new Promise((res) => {
+        const tick = () => {
+            if (exitRequested) {
+                Promise.allSettled(children.map((c) => new Promise((r) => {
+                    if (c.exitCode !== null)
+                        r();
+                    else
+                        c.on('exit', () => r());
+                }))).then(() => res({ success: true }));
+            }
+            else {
+                setTimeout(tick, 500);
+            }
+        };
+        tick();
+    });
+}
+// ---------- nestjs branch ----------
+async function runNestjs(projectRoot, context) {
+    // The built entry lives in different places per setup:
+    //   1. the project build target's declared outputPath (most precise),
+    //   2. <projectRoot>/dist/main.js          (standalone tsc layout),
+    //   3. <workspaceRoot>/dist/<projectRoot>/main.js  (standard Nx layout).
+    const projectName = context.projectName;
+    const buildTarget = projectName
+        ? context.projectsConfigurations?.projects[projectName]?.targets?.['build']
+        : undefined;
+    const outputPath = buildTarget?.options?.['outputPath'];
+    const candidates = [
+        ...(typeof outputPath === 'string' ? [(0, node_path_1.join)(context.root, outputPath, 'main.js')] : []),
+        (0, node_path_1.join)(projectRoot, 'dist', 'main.js'),
+        (0, node_path_1.join)(context.root, 'dist', (0, node_path_1.relative)(context.root, projectRoot), 'main.js'),
+    ];
+    const main = candidates.find((c) => (0, node_fs_1.existsSync)(c));
+    if (!main) {
+        console.error(`[agent-dev] No built NestJS entry found. Looked in:\n` +
+            candidates.map((c) => `  • ${c}`).join('\n') +
+            `\nBuild first: \`nx build ${projectName ?? '<project>'}\`.`);
+        return { success: false };
+    }
+    console.log(`[agent-dev] node ${main}`);
+    const child = (0, node_child_process_1.spawn)(process.execPath, [main], {
+        cwd: projectRoot,
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            LENSMCP_TRANSPORT: process.env['LENSMCP_TRANSPORT'] ?? 'http',
+            LENSMCP_EVENT_FILE: process.env['LENSMCP_EVENT_FILE'] ??
+                (0, node_path_1.join)(context.root, '.lensmcp', 'events.jsonl'),
+        },
+    });
+    return new Promise((res) => {
+        const onSignal = () => {
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { /* swallow */ }
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        child.on('exit', (code) => {
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+            res({ success: code === 0 });
+        });
+    });
+}
+// ---------- helpers ----------
+function locateBin(name, roots) {
+    for (const root of roots) {
+        const candidate = (0, node_path_1.join)(root, 'node_modules', '.bin', name);
+        if ((0, node_fs_1.existsSync)(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function resolveFirstExisting(names, root) {
+    for (const n of names) {
+        const p = (0, node_path_1.join)(root, n);
+        if ((0, node_fs_1.existsSync)(p))
+            return p;
+    }
+    return undefined;
+}
+/**
+ * The global npm root — the recommended `npm i -g lensmcp` puts the bundled
+ * artefacts there, not in the host workspace. Fast path derives it from the
+ * running node binary (nvm/standard unix layout); `npm root -g` is the
+ * fallback. Cached for the executor's lifetime.
+ */
+let cachedGlobalRoot;
+function globalNodeModules() {
+    if (cachedGlobalRoot !== undefined)
+        return cachedGlobalRoot ?? undefined;
+    const guess = (0, node_path_1.resolve)((0, node_path_1.dirname)(process.execPath), '..', 'lib', 'node_modules');
+    if ((0, node_fs_1.existsSync)(guess)) {
+        cachedGlobalRoot = guess;
+        return guess;
+    }
+    try {
+        const out = (0, node_child_process_1.execSync)('npm root -g', { encoding: 'utf8', timeout: 5000 }).trim();
+        cachedGlobalRoot = out && (0, node_fs_1.existsSync)(out) ? out : null;
+    }
+    catch {
+        cachedGlobalRoot = null;
+    }
+    return cachedGlobalRoot ?? undefined;
+}
+function findMcpBundle(workspaceRoot) {
+    const globalRoot = globalNodeModules();
+    const candidates = [
+        // Published host install: the bundled server inside the `lensmcp` package.
+        (0, node_path_1.join)(workspaceRoot, 'node_modules', 'lensmcp', 'bundled', 'main.js'),
+        // Global CLI install (`npm i -g lensmcp`).
+        ...(globalRoot ? [(0, node_path_1.join)(globalRoot, 'lensmcp', 'bundled', 'main.js')] : []),
+        // Pre-rename layout (kept for old installs).
+        (0, node_path_1.join)(workspaceRoot, 'node_modules', '@lensmcp', 'cli', 'bundled', 'main.js'),
+        // In-repo dev build (four-bucket layout).
+        (0, node_path_1.join)(workspaceRoot, 'servers', 'lensmcp-mcp', 'dist', 'main.js'),
+    ];
+    for (const c of candidates) {
+        if ((0, node_fs_1.existsSync)(c))
+            return c;
+    }
+    return undefined;
+}
+function findCaptureRunner(workspaceRoot) {
+    const globalRoot = globalNodeModules();
+    const candidates = [
+        // Published host install: bundled inside the `lensmcp` package (ship step).
+        (0, node_path_1.join)(workspaceRoot, 'node_modules', 'lensmcp', 'bundled', 'capture-runner.js'),
+        // Global CLI install (`npm i -g lensmcp`).
+        ...(globalRoot ? [(0, node_path_1.join)(globalRoot, 'lensmcp', 'bundled', 'capture-runner.js')] : []),
+        // Pre-bundling layout (kept for old installs).
+        (0, node_path_1.join)(workspaceRoot, 'node_modules', '@lensmcp', 'browser-capture', 'dist', 'capture-runner.js'),
+        // In-repo dev build.
+        (0, node_path_1.join)(workspaceRoot, 'libs', 'browser-capture', 'dist', 'capture-runner.js'),
+    ];
+    for (const c of candidates) {
+        if ((0, node_fs_1.existsSync)(c))
+            return c;
+    }
+    return undefined;
+}

package/executors/agent-dev/schema.d.ts

@@ -0,0 +1,9 @@
+export interface AgentDevExecutorSchema {
+  kind?: 'vite-react' | 'nestjs' | 'nextjs';
+  devTarget?: string;
+  projectRoot?: string;
+  chrome?: boolean;
+  headless?: boolean;
+  port?: number;
+  openUrl?: string;
+}

package/executors/agent-dev/schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "LensmcpAgentDev",
+  "title": "agent-dev",
+  "description": "Run a host project under the LensMCP lens.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "kind": {
+      "type": "string",
+      "enum": ["vite-react", "nestjs", "nextjs"],
+      "default": "vite-react"
+    },
+    "devTarget": {
+      "type": "string",
+      "description": "Nx target that starts the host's dev server (e.g. \"web:serve\"). If omitted, the executor runs `vite` on the current project."
+    },
+    "projectRoot": {
+      "type": "string",
+      "description": "Override the project root passed to Vite. Defaults to the running project's root."
+    },
+    "chrome": {
+      "type": "boolean",
+      "default": true,
+      "description": "Launch a Chrome sidecar attached to the dev URL."
+    },
+    "headless": {
+      "type": "boolean",
+      "default": true
+    },
+    "port": {
+      "type": "number",
+      "description": "Override the Vite dev port (default: project's vite.config.ts setting or 5173)."
+    },
+    "openUrl": {
+      "type": "string",
+      "description": "Override the URL Chrome navigates to."
+    }
+  },
+  "required": []
+}

package/executors/agent-verify/agent-verify.d.ts

@@ -0,0 +1,22 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { AgentVerifyExecutorSchema } from './schema';
+interface ExecutorResult {
+    success: boolean;
+}
+/**
+ * `agent-verify` — the deterministic verification loop the agent runs
+ * to know "did my fix work?".
+ *
+ * Phase 2 covers the frontend slice: typecheck (`tsc --noEmit`), lint
+ * (`eslint`), and build (`vite build`). Each stage runs sequentially;
+ * a stage failure marks the verify as `failed` but later stages still
+ * run so the agent gets a complete picture, not just the first error.
+ *
+ * The report is written to `.lensmcp/verifications/<project>-<ts>.json`
+ * and to `.lensmcp/verifications/latest.json` for easy resource access.
+ * The MCP-side `agent://latest-verification` resource (Phase 2.5) reads
+ * from `latest.json`.
+ */
+export default function agentVerifyExecutor(options: AgentVerifyExecutorSchema, context: ExecutorContext): Promise<ExecutorResult>;
+export {};
+//# sourceMappingURL=agent-verify.d.ts.map

package/executors/agent-verify/agent-verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-verify.d.ts","sourceRoot":"","sources":["../../../src/executors/agent-verify/agent-verify.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAE1D,UAAU,cAAc;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAmBD;;;;;;;;;;;;;GAaG;AACH,wBAA8B,mBAAmB,CAC/C,OAAO,EAAE,yBAAyB,EAClC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAyHzB"}

package/executors/agent-verify/agent-verify.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = agentVerifyExecutor;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * `agent-verify` — the deterministic verification loop the agent runs
+ * to know "did my fix work?".
+ *
+ * Phase 2 covers the frontend slice: typecheck (`tsc --noEmit`), lint
+ * (`eslint`), and build (`vite build`). Each stage runs sequentially;
+ * a stage failure marks the verify as `failed` but later stages still
+ * run so the agent gets a complete picture, not just the first error.
+ *
+ * The report is written to `.lensmcp/verifications/<project>-<ts>.json`
+ * and to `.lensmcp/verifications/latest.json` for easy resource access.
+ * The MCP-side `agent://latest-verification` resource (Phase 2.5) reads
+ * from `latest.json`.
+ */
+async function agentVerifyExecutor(options, context) {
+    const opts = {
+        kind: options.kind ?? 'vite-react',
+        skipTypecheck: options.skipTypecheck ?? false,
+        skipLint: options.skipLint ?? false,
+        skipBuild: options.skipBuild ?? false,
+        projectRoot: options.projectRoot,
+    };
+    const projectName = context.projectName ?? null;
+    const projectRoot = opts.projectRoot
+        ? (0, node_path_1.resolve)(context.root, opts.projectRoot)
+        : projectName && context.projectsConfigurations
+            ? (0, node_path_1.resolve)(context.root, context.projectsConfigurations.projects[projectName]?.root ?? '.')
+            : context.root;
+    const startedAt = Date.now();
+    const stages = [];
+    // 1. typecheck — `tsc --noEmit -p <root>` if a tsconfig is present.
+    if (!opts.skipTypecheck) {
+        const tscBin = locateBin('tsc', [projectRoot, context.root]);
+        const tsconfig = resolveFirstExisting(['tsconfig.json'], projectRoot);
+        if (!tscBin || !tsconfig) {
+            stages.push({ name: 'typecheck', result: 'skipped', durationMs: 0, summary: 'no tsc/tsconfig' });
+        }
+        else {
+            const t0 = Date.now();
+            console.log('[agent-verify] tsc --noEmit');
+            const r = (0, node_child_process_1.spawnSync)(tscBin, ['--noEmit', '-p', tsconfig], {
+                cwd: projectRoot,
+                stdio: 'inherit',
+            });
+            stages.push({
+                name: 'typecheck',
+                result: r.status === 0 ? 'passed' : 'failed',
+                durationMs: Date.now() - t0,
+                exitCode: r.status ?? -1,
+            });
+        }
+    }
+    else {
+        stages.push({ name: 'typecheck', result: 'skipped', durationMs: 0 });
+    }
+    // 2. lint — `eslint .` if eslint is present.
+    if (!opts.skipLint) {
+        const eslintBin = locateBin('eslint', [projectRoot, context.root]);
+        if (!eslintBin) {
+            stages.push({ name: 'lint', result: 'skipped', durationMs: 0, summary: 'no eslint' });
+        }
+        else {
+            const t0 = Date.now();
+            console.log('[agent-verify] eslint .');
+            const r = (0, node_child_process_1.spawnSync)(eslintBin, ['.'], { cwd: projectRoot, stdio: 'inherit' });
+            stages.push({
+                name: 'lint',
+                result: r.status === 0 ? 'passed' : 'failed',
+                durationMs: Date.now() - t0,
+                exitCode: r.status ?? -1,
+            });
+        }
+    }
+    else {
+        stages.push({ name: 'lint', result: 'skipped', durationMs: 0 });
+    }
+    // 3. build — `vite build` if vite is present.
+    if (!opts.skipBuild) {
+        const viteBin = locateBin('vite', [projectRoot, context.root]);
+        if (!viteBin) {
+            stages.push({ name: 'build', result: 'skipped', durationMs: 0, summary: 'no vite' });
+        }
+        else {
+            const viteConfig = resolveFirstExisting(['vite.config.ts', 'vite.config.js', 'vite.config.mjs'], projectRoot) ??
+                (0, node_path_1.join)(projectRoot, 'vite.config.ts');
+            const t0 = Date.now();
+            console.log('[agent-verify] vite build');
+            const r = (0, node_child_process_1.spawnSync)(viteBin, ['build', '--config', viteConfig, projectRoot], {
+                cwd: projectRoot,
+                stdio: 'inherit',
+            });
+            stages.push({
+                name: 'build',
+                result: r.status === 0 ? 'passed' : 'failed',
+                durationMs: Date.now() - t0,
+                exitCode: r.status ?? -1,
+            });
+        }
+    }
+    else {
+        stages.push({ name: 'build', result: 'skipped', durationMs: 0 });
+    }
+    const status = stages.some((s) => s.result === 'failed') ? 'failed' : 'passed';
+    const report = {
+        schemaVersion: 1,
+        project: projectName,
+        timestamp: new Date(startedAt).toISOString(),
+        durationMs: Date.now() - startedAt,
+        status,
+        stages,
+    };
+    const outDir = (0, node_path_1.join)(context.root, '.lensmcp', 'verifications');
+    try {
+        (0, node_fs_1.mkdirSync)(outDir, { recursive: true });
+        const ts = startedAt;
+        // Project names like `@lensmcp/example-web` contain `/`. Flatten so
+        // the report filename is a single path segment.
+        const safeName = (projectName ?? 'app').replace(/[^a-zA-Z0-9_-]+/g, '-');
+        const filename = `${safeName}-${ts}.json`;
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, filename), JSON.stringify(report, null, 2) + '\n');
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outDir, 'latest.json'), JSON.stringify(report, null, 2) + '\n');
+    }
+    catch (e) {
+        console.warn(`[agent-verify] could not write report: ${e.message}`);
+    }
+    for (const s of report.stages) {
+        console.log(`[agent-verify] ${s.name}: ${s.result}${s.exitCode !== undefined ? ` (exit ${s.exitCode})` : ''}`);
+    }
+    console.log(`[agent-verify] ${status} in ${report.durationMs}ms`);
+    return { success: status === 'passed' };
+}
+function locateBin(name, roots) {
+    for (const root of roots) {
+        const candidate = (0, node_path_1.join)(root, 'node_modules', '.bin', name);
+        if ((0, node_fs_1.existsSync)(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function resolveFirstExisting(names, root) {
+    for (const n of names) {
+        const p = (0, node_path_1.join)(root, n);
+        if ((0, node_fs_1.existsSync)(p))
+            return p;
+    }
+    return undefined;
+}
+// Unused helpers, kept available for future re-use by tools that may
+// drive the report differently.
+void node_path_1.dirname;

package/executors/agent-verify/schema.d.ts

@@ -0,0 +1,7 @@
+export interface AgentVerifyExecutorSchema {
+  kind?: 'vite-react';
+  projectRoot?: string;
+  skipTypecheck?: boolean;
+  skipLint?: boolean;
+  skipBuild?: boolean;
+}

package/executors/agent-verify/schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "LensmcpAgentVerify",
+  "title": "agent-verify",
+  "description": "Deterministic verification loop: typecheck → lint → build. Phase 2 frontend-only.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "kind": {
+      "type": "string",
+      "enum": ["vite-react"],
+      "default": "vite-react"
+    },
+    "projectRoot": {
+      "type": "string",
+      "description": "Override the project root. Defaults to the running project's root."
+    },
+    "skipTypecheck": { "type": "boolean", "default": false },
+    "skipLint": { "type": "boolean", "default": false },
+    "skipBuild": { "type": "boolean", "default": false }
+  },
+  "required": []
+}

package/executors.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "name": "@lensmcp/nx-plugin",
+  "version": "0.0.1",
+  "executors": {
+    "agent-dev": {
+      "implementation": "./dist/executors/agent-dev/agent-dev",
+      "schema": "./dist/executors/agent-dev/schema.json",
+      "description": "Start a project with the LensMCP lens attached (Vite dev server + Chrome sidecar + MCP server)."
+    },
+    "agent-build": {
+      "implementation": "./dist/executors/agent-build/agent-build",
+      "schema": "./dist/executors/agent-build/schema.json",
+      "description": "Instrumented production build that produces a bundle report and updates the baseline."
+    },
+    "agent-verify": {
+      "implementation": "./dist/executors/agent-verify/agent-verify",
+      "schema": "./dist/executors/agent-verify/schema.json",
+      "description": "Deterministic verification: typecheck → lint → build, with a per-run report under .lensmcp/verifications/."
+    }
+  }
+}

package/generators/init/init.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from '@nx/devkit';
+import type { InitGeneratorSchema } from './schema';
+export declare function initGenerator(tree: Tree, rawOptions?: InitGeneratorSchema): Promise<void>;
+export default initGenerator;
+//# sourceMappingURL=init.d.ts.map

package/generators/init/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/generators/init/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,IAAI,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAgDpD,wBAAsB,aAAa,CACjC,IAAI,EAAE,IAAI,EACV,UAAU,GAAE,mBAAwB,GACnC,OAAO,CAAC,IAAI,CAAC,CAiFf;AAkCD,eAAe,aAAa,CAAC"}