@grafana/create-plugin 7.12.3 → 7.14.0

package/src/codemods/agentic/resolve.ts

@@ -0,0 +1,165 @@
+import { confirmPrompt, output, selectPrompt } from '../../utils/utils.console.js';
+import { AGENT_DEFINITIONS } from './definitions.js';
+import { detectInstalledAgents, isInsideAgent, resolveAgentFromPath } from './detect.js';
+import { AgenticResolution, InstalledAgent } from './types.js';
+
+export interface ResolveAgenticOptions {
+  // raw minimist value: undefined = flag absent, '' = bare --agent, '<id>' or '<path>' = --agent=..., false = --no-agent
+  agentFlag: string | boolean | undefined;
+  isTTY?: boolean;
+  env?: NodeJS.ProcessEnv;
+  detect?: typeof detectInstalledAgents;
+}
+
+export async function resolveAgenticMode(options: ResolveAgenticOptions): Promise<AgenticResolution> {
+  const isTTY = options.isTTY ?? Boolean(process.stdout.isTTY && process.stdin.isTTY);
+  const detect = options.detect ?? detectInstalledAgents;
+
+  // checked before the inside-agent probe: --no-agent means no agent at all, and handing the step to an
+  // outer agent via a directive block would contradict that
+  if (options.agentFlag === false) {
+    return { mode: 'opted-out', reason: 'flag' };
+  }
+
+  if (isInsideAgent(options.env)) {
+    output.log({
+      title: 'Running inside an AI agent. The agent step will be handed to it instead of spawning another agent.',
+    });
+    return { mode: 'inside-agent' };
+  }
+
+  // the agent session is interactive, so it cannot run without a terminal to attach to
+  if (!isTTY) {
+    return { mode: 'unavailable', reason: 'no-tty' };
+  }
+
+  // --agent=<path>: an agent installed outside PATH
+  if (typeof options.agentFlag === 'string' && looksLikePath(options.agentFlag)) {
+    return { mode: 'enabled', agent: await resolveAgentFromPath(options.agentFlag) };
+  }
+
+  const installedAgents = await detect();
+
+  // --agent=<id>: pin a specific agent
+  if (typeof options.agentFlag === 'string' && options.agentFlag !== '') {
+    return { mode: 'enabled', agent: pinAgent(options.agentFlag, installedAgents) };
+  }
+
+  // bare --agent: enable without asking
+  if (options.agentFlag !== undefined) {
+    if (installedAgents.length === 0) {
+      throw new Error(
+        `--agent was passed but no supported agent CLI was found on this system. Supported agents: ${supportedAgentList()}. Pass --agent=<path> if one is installed outside your PATH.`
+      );
+    }
+    return resolveFromPick(installedAgents);
+  }
+
+  // no flag: opt in interactively
+  if (installedAgents.length === 0) {
+    return { mode: 'unavailable', reason: 'no-agents' };
+  }
+
+  return optInInteractively(installedAgents);
+}
+
+export const NO_AGENT_CHOICE = "Don't use an agent";
+
+// names the agent and its binary before asking, so the user knows exactly what will run on their behalf
+async function optInInteractively(installedAgents: InstalledAgent[]): Promise<AgenticResolution> {
+  output.log({
+    title: 'This addition includes instructions for an AI agent.',
+    body: [
+      'The agent runs on your own account and can edit files and run commands in this repository.',
+      ...installedAgents.map((agent) => `${agent.definition.displayName}: ${agent.binaryPath}`),
+    ],
+  });
+
+  if (installedAgents.length === 1) {
+    const [installedAgent] = installedAgents;
+    const optedIn = await safeConfirm(`Apply the instructions with ${installedAgent.definition.displayName}?`);
+    if (!optedIn) {
+      return { mode: 'opted-out', reason: 'declined' };
+    }
+    return { mode: 'enabled', agent: installedAgent };
+  }
+
+  const pickedAgent = await safeSelectAgent('Which agent should apply the instructions?', installedAgents, [
+    NO_AGENT_CHOICE,
+  ]);
+  if (!pickedAgent) {
+    return { mode: 'opted-out', reason: 'declined' };
+  }
+  return { mode: 'enabled', agent: pickedAgent };
+}
+
+function looksLikePath(agentFlag: string): boolean {
+  return agentFlag.includes('/');
+}
+
+async function resolveFromPick(installedAgents: InstalledAgent[]): Promise<AgenticResolution> {
+  const pickedAgent = await pickAgent(installedAgents);
+  if (!pickedAgent) {
+    return { mode: 'opted-out', reason: 'declined' };
+  }
+  return { mode: 'enabled', agent: pickedAgent };
+}
+
+function pinAgent(agentId: string, installedAgents: InstalledAgent[]): InstalledAgent {
+  const isKnownAgent = AGENT_DEFINITIONS.some((definition) => definition.id === agentId);
+  if (!isKnownAgent) {
+    throw new Error(
+      `Unknown agent "${agentId}". Supported agents: ${supportedAgentList()}. Pass a path instead to use an agent installed outside your PATH.`
+    );
+  }
+
+  const installedAgent = installedAgents.find((agent) => agent.definition.id === agentId);
+  if (!installedAgent) {
+    const installedList =
+      installedAgents.length > 0 ? installedAgents.map((agent) => agent.definition.id).join(', ') : 'none';
+    throw new Error(
+      `Agent "${agentId}" is not installed. Installed agents: ${installedList}. Pass --agent=<path> if it is installed outside your PATH.`
+    );
+  }
+
+  return installedAgent;
+}
+
+async function pickAgent(installedAgents: InstalledAgent[]): Promise<InstalledAgent | undefined> {
+  if (installedAgents.length === 1) {
+    output.log({ title: `Using ${installedAgents[0].definition.displayName} for this addition.` });
+    return installedAgents[0];
+  }
+
+  return safeSelectAgent('Multiple agents are installed. Which one should apply this addition?', installedAgents);
+}
+
+async function safeSelectAgent(
+  message: string,
+  installedAgents: InstalledAgent[],
+  extraChoices: string[] = []
+): Promise<InstalledAgent | undefined> {
+  try {
+    const choice = await selectPrompt(message, [
+      ...installedAgents.map((agent) => agent.definition.displayName),
+      ...extraChoices,
+    ]);
+    return installedAgents.find((agent) => agent.definition.displayName === choice);
+  } catch {
+    // enquirer rejects when the prompt is cancelled (ctrl+c) — treat as a decline
+    return undefined;
+  }
+}
+
+async function safeConfirm(message: string): Promise<boolean> {
+  try {
+    return await confirmPrompt(message);
+  } catch {
+    // enquirer rejects when the prompt is cancelled (ctrl+c) — treat as a decline
+    return false;
+  }
+}
+
+function supportedAgentList(): string {
+  return AGENT_DEFINITIONS.map((definition) => `${definition.displayName} (${definition.id})`).join(', ');
+}

package/src/codemods/agentic/runner.test.ts

@@ -0,0 +1,146 @@
+import { spawn, ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runAgentSession, AgentSessionOptions } from './runner.js';
+
+vi.mock('node:child_process');
+
+const spawnMock = vi.mocked(spawn);
+
+interface FakeChildBehavior {
+  onSigint?: 'exit' | 'ignore';
+}
+
+class FakeChild extends EventEmitter {
+  kill = vi.fn((signal: NodeJS.Signals) => {
+    if (signal === 'SIGINT' && this.behavior.onSigint === 'exit') {
+      setTimeout(() => this.emit('exit', 130, null), 5);
+    }
+    if (signal === 'SIGKILL') {
+      setTimeout(() => this.emit('exit', null, 'SIGKILL'), 5);
+    }
+    return true;
+  });
+
+  constructor(private behavior: FakeChildBehavior = { onSigint: 'exit' }) {
+    super();
+  }
+}
+
+function stubSpawn(child: FakeChild) {
+  spawnMock.mockReturnValue(child as unknown as ChildProcess);
+}
+
+describe('runAgentSession', () => {
+  let dir: string;
+  let handoffPath: string;
+  let sessionOptions: AgentSessionOptions;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    dir = mkdtempSync(join(tmpdir(), 'cp-runner-test-'));
+    handoffPath = join(dir, '013-example.json');
+    sessionOptions = {
+      binaryPath: '/usr/local/bin/claude',
+      args: ['--system-prompt', 'sys', 'user'],
+      cwd: dir,
+      handoffPath,
+      pollIntervalMs: 10,
+      killGraceMs: 5000,
+    };
+  });
+
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('should resolve with the handoff and stop the session once the handoff file appears', async () => {
+    const child = new FakeChild();
+    stubSpawn(child);
+    writeFileSync(handoffPath, '{"status":"success","summary":"applied"}');
+
+    const result = await runAgentSession(sessionOptions);
+
+    expect(result).toEqual({ outcome: 'handoff', handoff: { status: 'success', summary: 'applied' } });
+    expect(child.kill).toHaveBeenCalledWith('SIGINT');
+    expect(spawnMock).toHaveBeenCalledWith(
+      sessionOptions.binaryPath,
+      sessionOptions.args,
+      expect.objectContaining({ stdio: 'inherit', cwd: dir })
+    );
+  });
+
+  it('should escalate to SIGKILL when the agent ignores SIGINT after a valid handoff', async () => {
+    const child = new FakeChild({ onSigint: 'ignore' });
+    stubSpawn(child);
+    writeFileSync(handoffPath, '{"status":"success","summary":"applied"}');
+
+    const result = await runAgentSession({ ...sessionOptions, killGraceMs: 30 });
+
+    expect(result).toEqual({ outcome: 'handoff', handoff: { status: 'success', summary: 'applied' } });
+    expect(child.kill).toHaveBeenCalledWith('SIGINT');
+    expect(child.kill).toHaveBeenCalledWith('SIGKILL');
+  });
+
+  it('should treat an exit after a self-written handoff as a handoff', async () => {
+    const child = new FakeChild();
+    stubSpawn(child);
+
+    const resultPromise = runAgentSession({ ...sessionOptions, pollIntervalMs: 60_000 });
+    writeFileSync(handoffPath, '{"status":"failed","summary":"blocked"}');
+    setTimeout(() => child.emit('exit', 0, null), 10);
+
+    await expect(resultPromise).resolves.toEqual({
+      outcome: 'handoff',
+      handoff: { status: 'failed', summary: 'blocked' },
+    });
+  });
+
+  it('should classify an exit without a handoff as ambiguous', async () => {
+    const child = new FakeChild();
+    stubSpawn(child);
+
+    const resultPromise = runAgentSession(sessionOptions);
+    setTimeout(() => child.emit('exit', 1, null), 10);
+
+    await expect(resultPromise).resolves.toEqual({ outcome: 'ambiguous-exit', exitCode: 1, signal: null });
+  });
+
+  it('should classify an exit with an invalid handoff file as ambiguous', async () => {
+    const child = new FakeChild();
+    stubSpawn(child);
+    writeFileSync(handoffPath, 'not json at all');
+
+    const resultPromise = runAgentSession({ ...sessionOptions, pollIntervalMs: 60_000 });
+    setTimeout(() => child.emit('exit', 0, null), 10);
+
+    await expect(resultPromise).resolves.toEqual({ outcome: 'ambiguous-exit', exitCode: 0, signal: null });
+  });
+
+  it.each([
+    [130, null],
+    [143, null],
+    [null, 'SIGINT'],
+    [null, 'SIGTERM'],
+  ])('should classify exit code %s / signal %s as user-aborted', async (exitCode, signal) => {
+    const child = new FakeChild();
+    stubSpawn(child);
+
+    const resultPromise = runAgentSession(sessionOptions);
+    setTimeout(() => child.emit('exit', exitCode, signal), 10);
+
+    await expect(resultPromise).resolves.toEqual({ outcome: 'user-aborted' });
+  });
+
+  it('should classify a spawn error as ambiguous', async () => {
+    const child = new FakeChild();
+    stubSpawn(child);
+
+    const resultPromise = runAgentSession(sessionOptions);
+    setTimeout(() => child.emit('error', new Error('spawn ENOENT')), 5);
+
+    await expect(resultPromise).resolves.toEqual({ outcome: 'ambiguous-exit', exitCode: null, signal: null });
+  });
+});

package/src/codemods/agentic/runner.ts

@@ -0,0 +1,103 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { parseHandoff } from './handoff.js';
+import { AgentSessionResult, Handoff } from './types.js';
+
+const DEFAULT_POLL_INTERVAL_MS = 500;
+const DEFAULT_KILL_GRACE_MS = 5000;
+
+export interface AgentSessionOptions {
+  binaryPath: string;
+  args: string[];
+  env?: Record<string, string>;
+  cwd: string;
+  handoffPath: string;
+  pollIntervalMs?: number;
+  killGraceMs?: number;
+}
+
+export function runAgentSession(options: AgentSessionOptions): Promise<AgentSessionResult> {
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
+
+  return new Promise((resolve) => {
+    const child = spawn(options.binaryPath, options.args, {
+      stdio: 'inherit',
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+    });
+
+    let settled = false;
+    // set once the poller finds a valid handoff; the session is then being torn down
+    // and the exit handler must report the handoff rather than classify the exit
+    let pendingHandoff: Handoff | undefined;
+    let killTimer: NodeJS.Timeout | undefined;
+
+    const pollTimer = setInterval(async () => {
+      const handoff = await readHandoff(options.handoffPath);
+      if (!handoff || settled || pendingHandoff) {
+        return;
+      }
+      pendingHandoff = handoff;
+      clearInterval(pollTimer);
+      child.kill('SIGINT');
+      killTimer = setTimeout(() => child.kill('SIGKILL'), killGraceMs);
+    }, pollIntervalMs);
+
+    function settle(result: AgentSessionResult) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearInterval(pollTimer);
+      if (killTimer) {
+        clearTimeout(killTimer);
+      }
+      resetTerminal();
+      resolve(result);
+    }
+
+    child.on('error', () => {
+      settle({ outcome: 'ambiguous-exit', exitCode: null, signal: null });
+    });
+
+    child.on('exit', async (exitCode, signal) => {
+      if (pendingHandoff) {
+        settle({ outcome: 'handoff', handoff: pendingHandoff });
+        return;
+      }
+      // the agent may write the handoff and end the session on its own before the poller fires
+      const handoff = await readHandoff(options.handoffPath);
+      if (handoff) {
+        settle({ outcome: 'handoff', handoff });
+        return;
+      }
+      if (isUserAbort(exitCode, signal)) {
+        settle({ outcome: 'user-aborted' });
+        return;
+      }
+      settle({ outcome: 'ambiguous-exit', exitCode, signal });
+    });
+  });
+}
+
+async function readHandoff(handoffPath: string): Promise<Handoff | undefined> {
+  try {
+    const raw = await readFile(handoffPath, 'utf-8');
+    return parseHandoff(raw);
+  } catch {
+    // tolerate ENOENT while the agent is still working (and cache dir pruning mid-session)
+    return undefined;
+  }
+}
+
+function isUserAbort(exitCode: number | null, signal: NodeJS.Signals | null): boolean {
+  return exitCode === 130 || exitCode === 143 || signal === 'SIGINT' || signal === 'SIGTERM';
+}
+
+function resetTerminal(): void {
+  if (process.stdout.isTTY) {
+    // clear any styling the killed agent TUI left behind on the inherited stdio
+    process.stdout.write('\x1B[0m\n');
+  }
+}

package/src/codemods/agentic/types.ts

@@ -0,0 +1,50 @@
+export type AgentId = 'claude-code' | 'codex';
+
+export interface AgentInvocationContext {
+  systemPrompt: string;
+  userPrompt: string;
+  workspaceRoot: string;
+  handoffDir: string;
+}
+
+export interface AgentInvocation {
+  args: string[];
+  env?: Record<string, string>;
+}
+
+export interface AgentDefinition {
+  id: AgentId;
+  displayName: string;
+  // candidate binary names probed on PATH, in order
+  binaryNames: string[];
+  buildInteractive: (invocationContext: AgentInvocationContext) => AgentInvocation;
+}
+
+export interface InstalledAgent {
+  definition: AgentDefinition;
+  binaryPath: string;
+}
+
+// 'unavailable' and 'opted-out' are deliberately distinct: the first means no agent could be used, the
+// second means one could have been but the user said no. Only the first is an error.
+export type AgenticResolution =
+  | { mode: 'inside-agent' }
+  | { mode: 'unavailable'; reason: 'no-tty' | 'no-agents' }
+  | { mode: 'opted-out'; reason: 'flag' | 'declined' }
+  | { mode: 'enabled'; agent: InstalledAgent };
+
+export interface Handoff {
+  status: 'success' | 'failed';
+  summary: string;
+}
+
+export type AgentSessionResult =
+  | { outcome: 'handoff'; handoff: Handoff }
+  | { outcome: 'ambiguous-exit'; exitCode: number | null; signal: NodeJS.Signals | null }
+  | { outcome: 'user-aborted' };
+
+// no 'deferred' kind: deferral is decided from the resolution before a session is ever started
+export type AgenticStepResult =
+  | { kind: 'applied'; summary: string }
+  // the agent session ended without a valid handoff and the user chose to continue
+  | { kind: 'assumed-applied' };

package/src/codemods/agentic/verify.test.ts

@@ -0,0 +1,106 @@
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildVerifyWarning, runVerifyScripts } from './verify.js';
+
+function createWorkspace(scripts?: Record<string, string>): string {
+  const cwd = mkdtempSync(join(tmpdir(), 'cp-verify-'));
+  writeFileSync(join(cwd, 'package.json'), JSON.stringify(scripts ? { scripts } : {}));
+  return cwd;
+}
+
+describe('runVerifyScripts', () => {
+  it('should run every script in order and record its outcome', () => {
+    const cwd = createWorkspace({ typecheck: 'tsc', build: 'rspack', lint: 'eslint' });
+    const runScript = vi.fn((_pm: string, script: string) => script !== 'build');
+
+    const results = runVerifyScripts({
+      scripts: ['typecheck', 'build', 'lint'],
+      cwd,
+      packageManagerName: 'pnpm',
+      runScript,
+    });
+
+    expect(runScript.mock.calls).toEqual([
+      ['pnpm', 'typecheck', cwd],
+      ['pnpm', 'build', cwd],
+      ['pnpm', 'lint', cwd],
+    ]);
+    expect(results).toEqual([
+      { script: 'typecheck', outcome: 'passed' },
+      { script: 'build', outcome: 'failed' },
+      { script: 'lint', outcome: 'passed' },
+    ]);
+  });
+
+  it('should skip scripts the plugin does not define', () => {
+    const cwd = createWorkspace({ build: 'rspack' });
+    const runScript = vi.fn(() => true);
+
+    const results = runVerifyScripts({ scripts: ['typecheck', 'build'], cwd, packageManagerName: 'npm', runScript });
+
+    expect(runScript).toHaveBeenCalledTimes(1);
+    expect(results).toEqual([
+      { script: 'typecheck', outcome: 'missing' },
+      { script: 'build', outcome: 'passed' },
+    ]);
+  });
+
+  it('should treat every script as missing when package.json cannot be read', () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'cp-verify-'));
+    const runScript = vi.fn(() => true);
+
+    const results = runVerifyScripts({ scripts: ['build'], cwd, packageManagerName: 'npm', runScript });
+
+    expect(runScript).not.toHaveBeenCalled();
+    expect(results).toEqual([{ script: 'build', outcome: 'missing' }]);
+  });
+
+  it('should run nothing when the addition has no verify scripts', () => {
+    const runScript = vi.fn(() => true);
+
+    expect(runVerifyScripts({ scripts: [], cwd: createWorkspace(), packageManagerName: 'npm', runScript })).toEqual([]);
+    expect(runScript).not.toHaveBeenCalled();
+  });
+
+  it('should report a real script exit code', () => {
+    const cwd = createWorkspace({ pass: 'node -e "process.exit(0)"', fail: 'node -e "process.exit(1)"' });
+
+    const results = runVerifyScripts({ scripts: ['pass', 'fail'], cwd, packageManagerName: 'npm' });
+
+    expect(results).toEqual([
+      { script: 'pass', outcome: 'passed' },
+      { script: 'fail', outcome: 'failed' },
+    ]);
+  });
+});
+
+describe('buildVerifyWarning', () => {
+  it('should return undefined when every check passed', () => {
+    expect(buildVerifyWarning('rspack', 'npm', [{ script: 'build', outcome: 'passed' }])).toBeUndefined();
+  });
+
+  it('should return undefined when there were no checks', () => {
+    expect(buildVerifyWarning('rspack', 'npm', [])).toBeUndefined();
+  });
+
+  it('should list failed and skipped checks', () => {
+    const warning = buildVerifyWarning('rspack', 'pnpm', [
+      { script: 'typecheck', outcome: 'missing' },
+      { script: 'build', outcome: 'failed' },
+    ]);
+
+    expect(warning?.title).toBe('rspack was applied, but 1 of its checks failed.');
+    expect(warning?.body).toEqual([
+      'pnpm run typecheck  skipped: package.json has no "typecheck" script',
+      'pnpm run build  failed',
+      expect.stringContaining('git diff'),
+    ]);
+  });
+
+  it('should say checks could not run when none failed but some were missing', () => {
+    const warning = buildVerifyWarning('rspack', 'npm', [{ script: 'typecheck', outcome: 'missing' }]);
+
+    expect(warning?.title).toBe('rspack was applied, but some of its checks could not run.');
+  });
+});

package/src/codemods/agentic/verify.ts

@@ -0,0 +1,93 @@
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export type VerifyOutcome = 'passed' | 'failed' | 'missing';
+
+export interface VerifyResult {
+  script: string;
+  outcome: VerifyOutcome;
+}
+
+export interface VerifyOptions {
+  scripts: string[];
+  cwd: string;
+  packageManagerName: string;
+  runScript?: (packageManagerName: string, script: string, cwd: string) => boolean;
+}
+
+export interface VerifyWarning {
+  title: string;
+  body: string[];
+}
+
+// the agent runs the prompt's own Verify step and reports on itself. these scripts are run by
+// create-plugin after the session, so the final result never rests on the agent's account alone
+export function runVerifyScripts(options: VerifyOptions): VerifyResult[] {
+  const { scripts, cwd, packageManagerName, runScript = runPackageScript } = options;
+  const availableScripts = readPackageScripts(cwd);
+  const results: VerifyResult[] = [];
+
+  // sequential, and every script runs even after a failure, so the user sees the whole picture at once
+  for (const script of scripts) {
+    if (!availableScripts.has(script)) {
+      results.push({ script, outcome: 'missing' });
+      continue;
+    }
+    const hasPassed = runScript(packageManagerName, script, cwd);
+    results.push({ script, outcome: hasPassed ? 'passed' : 'failed' });
+  }
+
+  return results;
+}
+
+export function buildVerifyWarning(
+  additionName: string,
+  packageManagerName: string,
+  results: VerifyResult[]
+): VerifyWarning | undefined {
+  const failedResults = results.filter((result) => result.outcome !== 'passed');
+  if (failedResults.length === 0) {
+    return undefined;
+  }
+
+  const failedCount = failedResults.filter((result) => result.outcome === 'failed').length;
+  const title =
+    failedCount > 0
+      ? `${additionName} was applied, but ${failedCount} of its checks failed.`
+      : `${additionName} was applied, but some of its checks could not run.`;
+
+  return {
+    title,
+    body: [
+      ...failedResults.map(({ script, outcome }) =>
+        outcome === 'failed'
+          ? `${packageManagerName} run ${script}  failed`
+          : `${packageManagerName} run ${script}  skipped: package.json has no "${script}" script`
+      ),
+      'Nothing was committed. Review the changes with git diff before you commit them.',
+    ],
+  };
+}
+
+function readPackageScripts(cwd: string): Set<string> {
+  try {
+    const packageJson: { scripts?: Record<string, string> } = JSON.parse(
+      readFileSync(join(cwd, 'package.json'), 'utf-8')
+    );
+    return new Set(Object.keys(packageJson.scripts ?? {}));
+  } catch {
+    return new Set();
+  }
+}
+
+function runPackageScript(packageManagerName: string, script: string, cwd: string): boolean {
+  try {
+    // inherit stdio so the user sees the check's own output, exactly as if they ran it themselves.
+    // script names come from the additions registry, never from user input
+    execSync(`${packageManagerName} run ${script}`, { cwd, stdio: 'inherit' });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/codemods/migrations/migrations.ts

@@ -113,6 +113,20 @@ export default [
       'Fix @grafana/ui Combobox dropdown crashing in Jest: add an IntersectionObserver polyfill stub so ScrollIndicators (mounted when the dropdown opens) no longer throws ReferenceError in jsdom.',
     scriptPath: import.meta.resolve('./scripts/016-jest-intersection-observer.js'),
   },
+  {
+    name: '017-jest-30',
+    version: '7.13.0',
+    description:
+      'Update Jest to v30, which replaces micromatch with picomatch and drops the braces dependency flagged by vulnerability scanners.',
+    scriptPath: import.meta.resolve('./scripts/017-jest-30.js'),
+  },
+  {
+    name: '018-replace-eslint-webpack-plugin',
+    version: '7.13.0',
+    description:
+      'Replace eslint-webpack-plugin with diagnostics-webpack-plugin in the webpack config. eslint-webpack-plugin depends on micromatch, which pulls in the braces dependency flagged by vulnerability scanners.',
+    scriptPath: import.meta.resolve('./scripts/018-replace-eslint-webpack-plugin.js'),
+  },
   // Do not use LEGACY_UPDATE_CUTOFF_VERSION for new migrations. It is only used above to force migrations to run
   // for those written before the switch to updates as migrations.
   //