Skip to content

Commit 2d4028c

Browse files
clydinclydin
committed
refactor(@angular/cli): migrate build and test MCP tools into specialized target strategy handlers
Migrate build and unit-test MCP tools from standalone tools into specialized target strategy handlers in the tools/run-target subdirectory. Restrict BuildTargetStrategy to known official builders, parsing execution logs to extract output paths and extending payload metadata. Restrict UnitTestTargetStrategy to known test runner builders, auto-injecting non-interactive one-off watch mode flags and automatically configuring headless options for Karma jasmine suites. Handle all other targets and builders via the GenericTargetStrategy. (cherry picked from commit 5e8714e)
1 parent 327cc24 commit 2d4028c

11 files changed

Lines changed: 540 additions & 30 deletions

File tree

‎packages/angular/cli/src/commands/mcp/tools/run-target/build-target-strategy.ts‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
/**
2+
* @license
3+
* Copyright Google LLC All Rights Reserved.
4+
*
5+
* Use of this source code is governed by an MIT-style license that can be
6+
* found in the LICENSE file at https://angular.dev/license
7+
*/
8+
9+
import { getCommandErrorLogs } from '../../utils';
10+
import type { McpToolContext } from '../tool-registry';
11+
import { serializeOptions } from './options-serializer';
12+
import type { TargetStrategy } from './strategy';
13+
import type { RunTargetOutput, StrategyExecutionContext } from './types';
14+
15+
export class BuildTargetStrategy implements TargetStrategy {
16+
canHandle(targetName: string, builder?: string): boolean {
17+
return (
18+
targetName === 'build' &&
19+
(builder === '@angular-devkit/build-angular:application' ||
20+
builder === '@angular-devkit/build-angular:browser' ||
21+
builder === '@angular/build:application' ||
22+
builder === '@angular-devkit/build-angular:ng-packagr')
23+
);
24+
}
25+
26+
async execute(
27+
input: StrategyExecutionContext,
28+
context: McpToolContext,
29+
): Promise<RunTargetOutput> {
30+
const args = ['build', input.projectName];
31+
if (input.configuration) {
32+
args.push('-c', input.configuration);
33+
}
34+
35+
args.push(...serializeOptions(input.options));
36+
37+
let status: 'success' | 'failure' = 'success';
38+
let logs: string[];
39+
40+
try {
41+
const result = await context.host.executeNgCommand(args, { cwd: input.workspacePath });
42+
logs = result.logs;
43+
} catch (e) {
44+
status = 'failure';
45+
logs = getCommandErrorLogs(e);
46+
}
47+
48+
let outputPath: string | undefined;
49+
for (const line of logs) {
50+
const match = line.match(/Output location: (.*)/);
51+
if (match) {
52+
outputPath = match[1].trim();
53+
break;
54+
}
55+
}
56+
57+
return {
58+
status,
59+
logs,
60+
extensions: outputPath ? { outputPath } : undefined,
61+
};
62+
}
63+
}

‎packages/angular/cli/src/commands/mcp/tools/run-target/build-target-strategy_spec.ts‎

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,93 @@
1+
/**
2+
* @license
3+
* Copyright Google LLC All Rights Reserved.
4+
*
5+
* Use of this source code is governed by an MIT-style license that can be
6+
* found in the LICENSE file at https://angular.dev/license
7+
*/
8+
9+
import type { MockHost } from '../../testing/mock-host';
10+
import {
11+
type MockMcpToolContext,
12+
addProjectToWorkspace,
13+
createMockContext,
14+
} from '../../testing/test-utils';
15+
import { BuildTargetStrategy } from './build-target-strategy';
16+
17+
describe('BuildTargetStrategy', () => {
18+
let mockHost: MockHost;
19+
let mockContext: MockMcpToolContext;
20+
let strategy: BuildTargetStrategy;
21+
22+
beforeEach(() => {
23+
const mock = createMockContext();
24+
mockHost = mock.host;
25+
mockContext = mock.context;
26+
addProjectToWorkspace(mock.projects, 'my-app');
27+
strategy = new BuildTargetStrategy();
28+
});
29+
30+
describe('canHandle', () => {
31+
it('should match build target with official builders', () => {
32+
expect(strategy.canHandle('build', '@angular-devkit/build-angular:application')).toBeTrue();
33+
expect(strategy.canHandle('build', '@angular-devkit/build-angular:browser')).toBeTrue();
34+
expect(strategy.canHandle('build', '@angular/build:application')).toBeTrue();
35+
expect(strategy.canHandle('build', '@angular-devkit/build-angular:ng-packagr')).toBeTrue();
36+
});
37+
38+
it('should not match build target with custom builders', () => {
39+
expect(strategy.canHandle('build', 'custom-builder')).toBeFalse();
40+
expect(strategy.canHandle('build', undefined)).toBeFalse();
41+
});
42+
43+
it('should not match other targets', () => {
44+
expect(strategy.canHandle('test', '@angular-devkit/build-angular:browser')).toBeFalse();
45+
});
46+
});
47+
48+
describe('execute', () => {
49+
it('should spawn ng build and parse outputPath successfully', async () => {
50+
const buildLogs = ['Build successful!', 'Output location: dist/my-app'];
51+
mockHost.executeNgCommand.and.resolveTo({ logs: buildLogs });
52+
53+
const result = await strategy.execute(
54+
{
55+
workspacePath: '/test',
56+
projectName: 'my-app',
57+
targetName: 'build',
58+
targetDefinition: {
59+
builder: '@angular/build:application',
60+
},
61+
},
62+
mockContext,
63+
);
64+
65+
expect(mockHost.executeNgCommand).toHaveBeenCalledWith(['build', 'my-app'], {
66+
cwd: '/test',
67+
});
68+
expect(result.status).toBe('success');
69+
expect(result.logs).toEqual(buildLogs);
70+
expect(result.extensions).toEqual({ outputPath: 'dist/my-app' });
71+
});
72+
73+
it('should return undefined outputPath if parsing matches nothing', async () => {
74+
const buildLogs = ['Build successful!'];
75+
mockHost.executeNgCommand.and.resolveTo({ logs: buildLogs });
76+
77+
const result = await strategy.execute(
78+
{
79+
workspacePath: '/test',
80+
projectName: 'my-app',
81+
targetName: 'build',
82+
targetDefinition: {
83+
builder: '@angular/build:application',
84+
},
85+
},
86+
mockContext,
87+
);
88+
89+
expect(result.status).toBe('success');
90+
expect(result.extensions).toBeUndefined();
91+
});
92+
});
93+
});

‎packages/angular/cli/src/commands/mcp/tools/run-target/generic-target-strategy.ts‎

Lines changed: 8 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88

99
import { getCommandErrorLogs } from '../../utils';
1010
import type { McpToolContext } from '../tool-registry';
11+
import { serializeOptions } from './options-serializer';
1112
import type { TargetStrategy } from './strategy';
1213
import type { RunTargetOutput, StrategyExecutionContext } from './types';
1314

@@ -22,59 +23,41 @@ const BUILT_IN_COMMANDS = new Set([
2223
]);
2324

2425
export class GenericTargetStrategy implements TargetStrategy {
25-
canHandle(target: string, builder?: string): boolean {
26+
canHandle(targetName: string, builder?: string): boolean {
2627
return true; // Universal fallback strategy
2728
}
2829

2930
async execute(
3031
input: StrategyExecutionContext,
3132
context: McpToolContext,
3233
): Promise<RunTargetOutput> {
33-
if (input.target === 'serve' || input.options?.['watch'] === true) {
34+
if (input.targetName === 'serve' || input.options?.['watch'] === true) {
3435
throw new Error(
3536
`Watch mode execution (serve target or watch option) is not yet supported by 'run_target'. ` +
3637
`Please use the legacy 'devserver.start' / 'devserver.wait_for_build' tools instead.`,
3738
);
3839
}
3940

4041
const args: string[] = [];
41-
if (BUILT_IN_COMMANDS.has(input.target)) {
42-
args.push(input.target, input.projectName);
42+
if (BUILT_IN_COMMANDS.has(input.targetName)) {
43+
args.push(input.targetName, input.projectName);
4344
} else {
44-
args.push('run', `${input.projectName}:${input.target}`);
45+
args.push('run', `${input.projectName}:${input.targetName}`);
4546
}
4647

4748
if (input.configuration) {
4849
args.push('-c', input.configuration);
4950
}
5051

5152
let options = input.options;
52-
if (input.target === 'test') {
53+
if (input.targetName === 'test') {
5354
options = {
5455
...options,
5556
watch: false,
5657
};
5758
}
5859

59-
if (options) {
60-
for (const [key, value] of Object.entries(options)) {
61-
if (!/^[a-zA-Z0-9-_]+$/.test(key)) {
62-
throw new Error(
63-
`Invalid option key: '${key}'. Option keys must be alphanumeric, hyphens, or underscores.`,
64-
);
65-
}
66-
67-
if (typeof value === 'boolean') {
68-
args.push(value ? `--${key}` : `--no-${key}`);
69-
} else if (Array.isArray(value)) {
70-
for (const item of value) {
71-
args.push(`--${key}=${item}`);
72-
}
73-
} else if (value !== null && value !== undefined) {
74-
args.push(`--${key}=${value}`);
75-
}
76-
}
77-
}
60+
args.push(...serializeOptions(options));
7861

7962
let status: 'success' | 'failure' = 'success';
8063
let logs: string[];

‎packages/angular/cli/src/commands/mcp/tools/run-target/options-serializer.ts‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
/**
2+
* @license
3+
* Copyright Google LLC All Rights Reserved.
4+
*
5+
* Use of this source code is governed by an MIT-style license that can be
6+
* found in the LICENSE file at https://angular.dev/license
7+
*/
8+
9+
import type { OptionValue } from './types';
10+
11+
/**
12+
* Serializes a Zod-validated options record into standard CLI argument flags.
13+
* Enforces strict regex validation on option keys to prevent flag manipulation.
14+
*/
15+
export function serializeOptions(
16+
options: Record<string, OptionValue> | undefined,
17+
excludeKeys: Set<string> = new Set(),
18+
): string[] {
19+
const args: string[] = [];
20+
if (!options) {
21+
return args;
22+
}
23+
24+
for (const [key, value] of Object.entries(options)) {
25+
if (excludeKeys.has(key)) {
26+
continue;
27+
}
28+
29+
if (!/^[a-zA-Z0-9-_]+$/.test(key)) {
30+
throw new Error(
31+
`Invalid option key: '${key}'. Option keys must be alphanumeric, hyphens, or underscores.`,
32+
);
33+
}
34+
35+
if (typeof value === 'boolean') {
36+
args.push(value ? `--${key}` : `--no-${key}`);
37+
} else if (Array.isArray(value)) {
38+
for (const item of value) {
39+
args.push(`--${key}=${item}`);
40+
}
41+
} else if (value !== null && value !== undefined) {
42+
args.push(`--${key}=${value}`);
43+
}
44+
}
45+
46+
return args;
47+
}

‎packages/angular/cli/src/commands/mcp/tools/run-target/options-serializer_spec.ts‎

Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
/**
2+
* @license
3+
* Copyright Google LLC All Rights Reserved.
4+
*
5+
* Use of this source code is governed by an MIT-style license that can be
6+
* found in the LICENSE file at https://angular.dev/license
7+
*/
8+
9+
import { serializeOptions } from './options-serializer';
10+
11+
describe('run-target options-serializer', () => {
12+
describe('serializeOptions', () => {
13+
it('should return empty array if options are undefined', () => {
14+
expect(serializeOptions(undefined)).toEqual([]);
15+
});
16+
17+
it('should serialize boolean options correctly', () => {
18+
expect(serializeOptions({ fix: true, quiet: false })).toEqual(['--fix', '--no-quiet']);
19+
});
20+
21+
it('should serialize string and number options correctly', () => {
22+
expect(serializeOptions({ browsers: 'Chrome', timeout: 5000 })).toEqual([
23+
'--browsers=Chrome',
24+
'--timeout=5000',
25+
]);
26+
});
27+
28+
it('should serialize array options as multiple occurrences of the flag', () => {
29+
expect(serializeOptions({ include: ['a', 'b'] })).toEqual(['--include=a', '--include=b']);
30+
});
31+
32+
it('should ignore excluded keys successfully', () => {
33+
expect(serializeOptions({ watch: true, fix: true }, new Set(['watch']))).toEqual(['--fix']);
34+
});
35+
36+
it('should ignore null and undefined values successfully', () => {
37+
// eslint-disable-next-line @typescript-eslint/no-explicit-any
38+
expect(serializeOptions({ empty: null, missing: undefined, fix: true } as any)).toEqual([
39+
'--fix',
40+
]);
41+
});
42+
43+
it('should throw an error if key is malformed (whitespace or special characters)', () => {
44+
expect(() => serializeOptions({ 'fix --danger': true })).toThrowError(
45+
/Invalid option key: 'fix --danger'/,
46+
);
47+
});
48+
});
49+
});

‎packages/angular/cli/src/commands/mcp/tools/run-target/run-target.ts‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,12 +9,14 @@
99
import { createStructuredContentOutput } from '../../utils';
1010
import { resolveWorkspaceAndProject } from '../../workspace-utils';
1111
import { type McpToolContext, declareTool } from '../tool-registry';
12+
import { BuildTargetStrategy } from './build-target-strategy';
1213
import { GenericTargetStrategy } from './generic-target-strategy';
1314
import type { TargetStrategy } from './strategy';
1415
import { type RunTargetInput, runTargetInputSchema, runTargetOutputSchema } from './types';
16+
import { UnitTestTargetStrategy } from './unit-test-strategy';
1517

1618
const FALLBACK_STRATEGY = new GenericTargetStrategy();
17-
const STRATEGIES: TargetStrategy[] = [];
19+
const STRATEGIES: TargetStrategy[] = [new BuildTargetStrategy(), new UnitTestTargetStrategy()];
1820

1921
export async function runTarget(input: RunTargetInput, context: McpToolContext) {
2022
const { workspace, workspacePath, projectName } = await resolveWorkspaceAndProject({
@@ -34,7 +36,8 @@ export async function runTarget(input: RunTargetInput, context: McpToolContext)
3436
{
3537
workspacePath,
3638
projectName,
37-
target: input.target,
39+
targetName: input.target,
40+
targetDefinition,
3841
configuration: input.configuration,
3942
options: input.options,
4043
},
@@ -59,6 +62,9 @@ This is the single, unified interface for executing all project tasks natively.
5962
</Use Cases>
6063
<Operational Notes>
6164
* Mandatory Discovery: You MUST discover available project targets by calling 'list_projects' first.
65+
* Headless Testing: For official builders, the test target automatically runs in headless mode
66+
and disables watch mode to guarantee clean execution.
67+
* Output Paths: For official builders, successful builds return the build directory in 'outputPath' under the extensions metadata.
6268
* Watch mode (serve target or watch options) is NOT yet supported in this version of run_target.
6369
You MUST use the legacy 'devserver.*' tools for background server lifecycles.
6470
</Operational Notes>`,

‎packages/angular/cli/src/commands/mcp/tools/run-target/strategy.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ import type { RunTargetOutput, StrategyExecutionContext } from './types';
1111

1212
export interface TargetStrategy {
1313
/** Whether this strategy is responsible for handling the given target/builder */
14-
canHandle(target: string, builder?: string): boolean;
14+
canHandle(targetName: string, builder?: string): boolean;
1515

1616
/** Executes the target using this strategy */
1717
execute(input: StrategyExecutionContext, context: McpToolContext): Promise<RunTargetOutput>;

‎packages/angular/cli/src/commands/mcp/tools/run-target/types.ts‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,12 @@ export type RunTargetOutput = z.infer<typeof runTargetOutputSchema>;
4949
export interface StrategyExecutionContext {
5050
workspacePath: string;
5151
projectName: string;
52-
target: string;
52+
targetName: string;
53+
targetDefinition?: {
54+
builder: string;
55+
options?: Record<string, unknown>;
56+
configurations?: Record<string, Record<string, unknown> | undefined>;
57+
};
5358
configuration?: string;
5459
options?: Record<string, OptionValue>;
5560
}

0 commit comments

Comments
 (0)