@uipath/solution-tool 1.206.0-preview.301 → 1.207.0-preview.305
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/{archive-extract-ma0gy822.js → archive-extract-afgwacbg.js} +3 -3
- package/dist/{cleanup-command-service-8whhrsvy.js → cleanup-command-service-j9kawew9.js} +20 -15
- package/dist/deploy-delete-service-1erqap9a.js +23 -0
- package/dist/deploy-run-service-jbs6dxye.js +24 -0
- package/dist/{deploy-status-service-at6cxp1a.js → deploy-status-service-4zn90vds.js} +49 -25
- package/dist/deploy.js +21 -20
- package/dist/{deployment-search-40dknsk1.js → deployment-search-dwzahe4v.js} +9 -9
- package/dist/feed-resolver-d14rdjss.js +31 -0
- package/dist/feed-scope-failure-w16mze3z.js +20 -0
- package/dist/{feed-session-dvyfw5k7.js → feed-session-f2sby6t8.js} +6 -6
- package/dist/{first-party-service-6gf3n6d8.js → first-party-service-7cggb17y.js} +1 -1
- package/dist/folder-runtime-check-586c41dq.js +25 -0
- package/dist/{governance-options-am1hfj5b.js → governance-options-y2xsv7ff.js} +7 -7
- package/dist/{packager-tool-5vf0v538.js → index-6ma58k47.js} +33 -708
- package/dist/{index-p3x7ztdr.js → index-795rsz0e.js} +1 -1
- package/dist/{index-yjvmjpdn.js → index-pzkzbqbs.js} +12 -11
- package/dist/{index-1cfw8mj0.js → index-wfqzwh7k.js} +9 -7
- package/dist/index.js +26 -26
- package/dist/init.js +10 -10
- package/dist/{list-vsecskj1.js → list-6pe1nab5.js} +11 -11
- package/dist/models/pack-command-types.d.ts +12 -0
- package/dist/{node-vndr59bc.js → node-13wj5mzd.js} +6 -6
- package/dist/pack-command-service-j9bqnsn1.js +32 -0
- package/dist/{pack-project-re7s480k.js → pack-project-3sdddc42.js} +21 -18
- package/dist/pack.js +25 -22
- package/dist/{package-id-rx8gq6y2.js → package-id-5j4q232a.js} +3 -3
- package/dist/{packager-tool-vgrswa8p.js → packager-tool-1db1wqdy.js} +30 -8
- package/dist/{packager-tool-vx2c68sb.js → packager-tool-1dsxhz1r.js} +2 -2
- package/dist/{packager-tool-t2r6z24f.js → packager-tool-1tvhgac9.js} +15 -6
- package/dist/{packager-tool-4pt71nf1.js → packager-tool-2atxqqgd.js} +49 -24
- package/dist/packager-tool-3ft8hywr.js +449 -0
- package/dist/{packager-tool-g1c0xdh2.js → packager-tool-46x80z85.js} +8 -4
- package/dist/{packager-tool-gjfb0wcy.js → packager-tool-4hm40a32.js} +8 -74
- package/dist/{packager-tool-f15an17m.js → packager-tool-5p1vy335.js} +1 -1
- package/dist/packager-tool-612prgtc.js +140 -0
- package/dist/packager-tool-7gqn5apd.js +72 -0
- package/dist/{packager-tool-aws5w512.js → packager-tool-887bkh9y.js} +1 -1
- package/dist/{packager-tool-vj88gh5b.js → packager-tool-8tckw03n.js} +28 -9
- package/dist/{packager-tool-9vtp28fb.js → packager-tool-93qy1v8m.js} +52 -15
- package/dist/{packager-tool-fx4ws49n.js → packager-tool-cenfraf4.js} +2 -2
- package/dist/{packager-tool-chff74yz.js → packager-tool-cr1khqtm.js} +103 -166
- package/dist/{packager-tool-6tn79r1b.js → packager-tool-da3hvfyn.js} +528 -202
- package/dist/{packager-tool-2zn98p5r.js → packager-tool-dd937g7k.js} +4 -4
- package/dist/{packager-tool-a7s0gbxs.js → packager-tool-devc4w73.js} +7 -2
- package/dist/{packager-tool-v7h8s6yj.js → packager-tool-ewbkaecg.js} +18 -11
- package/dist/{packager-tool-d7v4083a.js → packager-tool-g08b669a.js} +22 -18
- package/dist/{packager-tool-m07vyk89.js → packager-tool-gb3dq79g.js} +36 -9
- package/dist/{packager-tool-395kmy70.js → packager-tool-gmbcn83x.js} +3 -3
- package/dist/{packager-tool-btz44ase.js → packager-tool-jhtsana2.js} +119 -52
- package/dist/{packager-tool-4rvfxkyh.js → packager-tool-jtg2arr8.js} +20 -8
- package/dist/{packager-tool-t39pjz7n.js → packager-tool-jtvhkavz.js} +48 -6
- package/dist/packager-tool-kffz64hn.js +279 -0
- package/dist/{packager-tool-p5322gew.js → packager-tool-kmwjscby.js} +88 -10
- package/dist/{packager-tool-ppj5f4y7.js → packager-tool-n1zrk6zv.js} +4 -2
- package/dist/{packager-tool-avrdp2za.js → packager-tool-pmc5txbm.js} +4 -6
- package/dist/{packager-tool-egc54x78.js → packager-tool-qhht1tc9.js} +2408 -771
- package/dist/{packager-tool-zcqfq3vc.js → packager-tool-qm876ezh.js} +84 -29
- package/dist/{packager-tool-resolver-30hxk8vm.js → packager-tool-resolver-y52kztnx.js} +6 -6
- package/dist/{packager-tool-3ejz0af8.js → packager-tool-rhg3mwkn.js} +14 -8
- package/dist/{packager-tool-ckrt4gyr.js → packager-tool-t9zked1m.js} +3 -3
- package/dist/{packager-tool-36w7az7k.js → packager-tool-tat0qs6z.js} +26 -10
- package/dist/packager-tool-tf0rn1tp.js +741 -0
- package/dist/{packager-tool-p5aar2k0.js → packager-tool-tmba5jv0.js} +140 -10
- package/dist/{packager-tool-vk3e239z.js → packager-tool-tqe3m1xp.js} +6 -6
- package/dist/{packager-tool-1ctvbx0h.js → packager-tool-tr3ttz5c.js} +1 -1
- package/dist/{packager-tool-k9dk39tg.js → packager-tool-txygqgb2.js} +3 -3
- package/dist/packager-tool-v6jcys3s.js +46 -0
- package/dist/packager-tool-w35s60sx.js +179 -0
- package/dist/{packager-tool-axqk17xw.js → packager-tool-xbfr6y2x.js} +142 -34
- package/dist/{packager-tool-2qsbh4kd.js → packager-tool-yfcscjfp.js} +50 -12
- package/dist/{packager-tool-ay4j9x92.js → packager-tool-ykq6gmhc.js} +19 -8
- package/dist/packager-tool.js +2 -2
- package/dist/prepare-solution-resources-sk3tyy8b.js +26 -0
- package/dist/{project-command-utils-82tja3k0.js → project-command-utils-7ygs8xq0.js} +20 -13
- package/dist/project-contributions-nzh06q0y.js +31 -0
- package/dist/project-identity-telemetry-47k2g7nq.js +18 -0
- package/dist/publish.js +14 -14
- package/dist/{resource-mutations-h6wfdqr4.js → resource-mutations-qcz2vcxe.js} +9 -9
- package/dist/{resource-version-lookup-xzgnvr48.js → resource-version-lookup-w3kzh4z9.js} +9 -9
- package/dist/resource.js +9 -9
- package/dist/{restore-command-service-wgqxp5tb.js → restore-command-service-m6c8fb7q.js} +20 -15
- package/dist/run-service-cmrzccnm.js +1055 -0
- package/dist/services/deploy-activate-service.d.ts +5 -2
- package/dist/services/deploy-config-file.d.ts +24 -0
- package/dist/services/deploy-delete-service.d.ts +1 -1
- package/dist/services/deploy-run-service.d.ts +8 -1
- package/dist/services/deploy-uninstall-service.d.ts +4 -2
- package/dist/services/deploy-upgrade-service.d.ts +23 -2
- package/dist/services/deployment-feed-locator.d.ts +19 -6
- package/dist/services/deployment-links.d.ts +16 -0
- package/dist/services/deployment-progress.d.ts +10 -0
- package/dist/services/deployment-search.d.ts +15 -2
- package/dist/services/deployment-state.d.ts +9 -0
- package/dist/services/feed-resolver.d.ts +17 -0
- package/dist/services/feed-selection.d.ts +59 -0
- package/dist/services/folder-runtime-check.d.ts +107 -0
- package/dist/services/incomplete-feed-sweep.d.ts +6 -0
- package/dist/services/pack-command-service.d.ts +6 -0
- package/dist/services/pack-project.d.ts +1 -1
- package/dist/services/package-metadata-rewrite.d.ts +13 -0
- package/dist/services/personal-workspace-resolver.d.ts +4 -1
- package/dist/services/prepare-solution-resources.d.ts +11 -6
- package/dist/services/project-contributions.d.ts +26 -2
- package/dist/services/project-identity-telemetry.d.ts +31 -0
- package/dist/services/solution-members.d.ts +31 -0
- package/dist/{ship-telemetry-19gx83af.js → ship-telemetry-9djqndmy.js} +4 -4
- package/dist/{solution-auth-jxcgd2m0.js → solution-auth-0e3qm74f.js} +3 -3
- package/dist/{solution-definition-helper-tqwd6cxn.js → solution-definition-helper-bkyhs1bd.js} +1 -1
- package/dist/{solution-identity-c23d9bfv.js → solution-identity-j63p6n81.js} +4 -4
- package/dist/templates/AGENTS.md +131 -24
- package/dist/tool.js +26 -26
- package/package.json +2 -2
- package/dist/deploy-delete-service-dwd4qb1m.js +0 -23
- package/dist/deploy-run-service-0kzfrvnn.js +0 -23
- package/dist/feed-resolver-w4y5aspe.js +0 -27
- package/dist/feed-scope-failure-4ef9zxcx.js +0 -20
- package/dist/pack-command-service-k7ebbfya.js +0 -29
- package/dist/packager-tool-vrqbbh01.js +0 -182
- package/dist/packager-tool-wwzg88qy.js +0 -74
- package/dist/prepare-solution-resources-h7zvnncd.js +0 -26
- package/dist/project-contributions-xx560n8y.js +0 -27
- package/dist/run-service-2rc4we5q.js +0 -506
|
@@ -0,0 +1,1055 @@
|
|
|
1
|
+
import {
|
|
2
|
+
getLoginStatusAsync
|
|
3
|
+
} from "./packager-tool-jtvhkavz.js";
|
|
4
|
+
import {
|
|
5
|
+
getFileSystem
|
|
6
|
+
} from "./packager-tool-1db1wqdy.js";
|
|
7
|
+
import {
|
|
8
|
+
ProjectDimensions,
|
|
9
|
+
solutionIdentityProperties,
|
|
10
|
+
projectKey,
|
|
11
|
+
PROJECT_IDENTITY_LOOKUP_BUDGET_MS,
|
|
12
|
+
withinProjectIdentityBudget,
|
|
13
|
+
catchError,
|
|
14
|
+
carriedInstructions,
|
|
15
|
+
isProjectTelemetryDisabled
|
|
16
|
+
} from "./packager-tool-gb3dq79g.js";
|
|
17
|
+
import {
|
|
18
|
+
logger,
|
|
19
|
+
processContext,
|
|
20
|
+
PollOutcome,
|
|
21
|
+
pollUntil
|
|
22
|
+
} from "./packager-tool-xbfr6y2x.js";
|
|
23
|
+
import {
|
|
24
|
+
FPS_DEBUG_EXECUTOR,
|
|
25
|
+
DEVELOPMENT_RUNTIME_TYPE,
|
|
26
|
+
ORCHESTRATOR_PROJECT_TYPES,
|
|
27
|
+
assembleJitFpsProperties,
|
|
28
|
+
RunResult,
|
|
29
|
+
executorsFactoryRepository,
|
|
30
|
+
ensureExecutorFactory,
|
|
31
|
+
JitEntryCollector,
|
|
32
|
+
ProjectRunner
|
|
33
|
+
} from "./packager-tool-3ft8hywr.js";
|
|
34
|
+
import"./packager-tool-46x80z85.js";
|
|
35
|
+
import {
|
|
36
|
+
isDebugProvisioningTerminal2,
|
|
37
|
+
isDebugProvisioningSucceeded2,
|
|
38
|
+
getProjectDebugStatus2
|
|
39
|
+
} from "./packager-tool-93qy1v8m.js";
|
|
40
|
+
import"./packager-tool-rj2d1g0w.js";
|
|
41
|
+
import {
|
|
42
|
+
SessionsApi,
|
|
43
|
+
createOrchestratorConfig,
|
|
44
|
+
resolveFolder
|
|
45
|
+
} from "./packager-tool-qhht1tc9.js";
|
|
46
|
+
import {
|
|
47
|
+
getSolutionAuthContext2
|
|
48
|
+
} from "./packager-tool-n1zrk6zv.js";
|
|
49
|
+
import"./packager-tool-devc4w73.js";
|
|
50
|
+
import {
|
|
51
|
+
createResourceBuilderServices2
|
|
52
|
+
} from "./packager-tool-cr1khqtm.js";
|
|
53
|
+
import"./packager-tool-jtg2arr8.js";
|
|
54
|
+
import"./packager-tool-qm876ezh.js";
|
|
55
|
+
import"./packager-tool-887bkh9y.js";
|
|
56
|
+
import"./packager-tool-5p1vy335.js";
|
|
57
|
+
import"./packager-tool-qzcd5c9s.js";
|
|
58
|
+
import"./packager-tool-dd937g7k.js";
|
|
59
|
+
import"./packager-tool-yfcscjfp.js";
|
|
60
|
+
import"./packager-tool-ykq6gmhc.js";
|
|
61
|
+
import {
|
|
62
|
+
readSolutionProjects
|
|
63
|
+
} from "./packager-tool-w35s60sx.js";
|
|
64
|
+
import"./packager-tool-t9zked1m.js";
|
|
65
|
+
import"./packager-tool-2atxqqgd.js";
|
|
66
|
+
import"./packager-tool-tqe3m1xp.js";
|
|
67
|
+
import {
|
|
68
|
+
resolvePersonalWorkspace,
|
|
69
|
+
listSelectablePublishLocations
|
|
70
|
+
} from "./packager-tool-ewbkaecg.js";
|
|
71
|
+
import {
|
|
72
|
+
publishSolutionAsync2
|
|
73
|
+
} from "./packager-tool-8tckw03n.js";
|
|
74
|
+
import {
|
|
75
|
+
packSolutionAsync2
|
|
76
|
+
} from "./packager-tool-gmbcn83x.js";
|
|
77
|
+
import"./packager-tool-4hm40a32.js";
|
|
78
|
+
import"./packager-tool-tr3ttz5c.js";
|
|
79
|
+
import {
|
|
80
|
+
toPortableRelativePath2,
|
|
81
|
+
findSolutionFileUpward
|
|
82
|
+
} from "./packager-tool-kmwjscby.js";
|
|
83
|
+
|
|
84
|
+
// src/services/run-service.ts
|
|
85
|
+
import { hostname } from "node:os";
|
|
86
|
+
|
|
87
|
+
// ../solution-sdk/src/invocation-graph.ts
|
|
88
|
+
async function resolveReachableProjectsAsync(input) {
|
|
89
|
+
const { projects, lead, callsOf, cancellationToken } = input;
|
|
90
|
+
const reached = new Set([lead]);
|
|
91
|
+
const queue = [lead];
|
|
92
|
+
const edges = [];
|
|
93
|
+
const keepAll = (keptAll) => ({
|
|
94
|
+
projects,
|
|
95
|
+
edges,
|
|
96
|
+
keptAll
|
|
97
|
+
});
|
|
98
|
+
for (let next = queue.shift();next; next = queue.shift()) {
|
|
99
|
+
const from = next;
|
|
100
|
+
cancellationToken?.throwIfAborted();
|
|
101
|
+
let answer;
|
|
102
|
+
try {
|
|
103
|
+
answer = await callsOf(from);
|
|
104
|
+
} catch (error) {
|
|
105
|
+
cancellationToken?.throwIfAborted();
|
|
106
|
+
return keepAll({
|
|
107
|
+
kind: "failed",
|
|
108
|
+
project: from.name,
|
|
109
|
+
message: `Could not list the process calls of project '${from.name}': ` + `${error instanceof Error ? error.message : String(error)}. ` + "Every project of the solution takes part."
|
|
110
|
+
});
|
|
111
|
+
}
|
|
112
|
+
cancellationToken?.throwIfAborted();
|
|
113
|
+
if (answer.status === "unknown") {
|
|
114
|
+
return keepAll({
|
|
115
|
+
kind: "unknown",
|
|
116
|
+
project: from.name,
|
|
117
|
+
message: `Project '${from.name}' cannot list its process calls: ${answer.reason}. ` + "Every project of the solution takes part."
|
|
118
|
+
});
|
|
119
|
+
}
|
|
120
|
+
for (const call of answer.calls) {
|
|
121
|
+
const processName = call.processName?.trim();
|
|
122
|
+
if (!processName) {
|
|
123
|
+
return keepAll({
|
|
124
|
+
kind: "dynamicCall",
|
|
125
|
+
project: from.name,
|
|
126
|
+
message: `Project '${from.name}' starts a process whose name is an expression` + `${describeCallSite(call)}, so every project of the solution takes part.`
|
|
127
|
+
});
|
|
128
|
+
}
|
|
129
|
+
const wanted = processName.toLowerCase();
|
|
130
|
+
const targets = projects.filter((p) => p.name.toLowerCase() === wanted);
|
|
131
|
+
if (targets.length === 0) {
|
|
132
|
+
return keepAll({
|
|
133
|
+
kind: "externalCall",
|
|
134
|
+
project: from.name,
|
|
135
|
+
message: `Project '${from.name}' starts process '${processName}'${describeCallSite(call)}, ` + "which is not in the solution. A process outside the solution can call any project " + "of the solution, so every project takes part."
|
|
136
|
+
});
|
|
137
|
+
}
|
|
138
|
+
for (const to of targets) {
|
|
139
|
+
if (to === from) {
|
|
140
|
+
continue;
|
|
141
|
+
}
|
|
142
|
+
edges.push({
|
|
143
|
+
from,
|
|
144
|
+
to,
|
|
145
|
+
...call.activityId ? { activityId: call.activityId } : {},
|
|
146
|
+
...call.workflowPath ? { workflowPath: call.workflowPath } : {}
|
|
147
|
+
});
|
|
148
|
+
if (!reached.has(to)) {
|
|
149
|
+
reached.add(to);
|
|
150
|
+
queue.push(to);
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
return {
|
|
156
|
+
projects: projects.filter((p) => reached.has(p)),
|
|
157
|
+
edges
|
|
158
|
+
};
|
|
159
|
+
}
|
|
160
|
+
function describeCallSite(call) {
|
|
161
|
+
const parts = [call.workflowPath, call.activityId].filter((part) => !!part);
|
|
162
|
+
return parts.length > 0 ? ` (${parts.join(", ")})` : "";
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
// ../solution-sdk/src/project-context.ts
|
|
166
|
+
function record(value) {
|
|
167
|
+
return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
|
|
168
|
+
}
|
|
169
|
+
async function readProjectSolutionContext(projectDirectory, fs = getFileSystem()) {
|
|
170
|
+
try {
|
|
171
|
+
const selected = fs.path.resolve(projectDirectory);
|
|
172
|
+
const selectedStat = await fs.stat(selected);
|
|
173
|
+
if (!selectedStat?.isDirectory() && !selectedStat?.isFile())
|
|
174
|
+
return;
|
|
175
|
+
const selectedDirectory = selectedStat.isDirectory() ? selected : fs.path.dirname(selected);
|
|
176
|
+
const directory = await fs.realpath(selectedDirectory);
|
|
177
|
+
const file = await findSolutionFileUpward(fs, selectedDirectory);
|
|
178
|
+
const stat = await fs.stat(file);
|
|
179
|
+
if (!stat?.isFile() || stat.size > 1024 * 1024)
|
|
180
|
+
return;
|
|
181
|
+
const manifest = record(JSON.parse(await fs.readFile(file, "utf-8") ?? ""));
|
|
182
|
+
if (typeof manifest?.SolutionId !== "string" || !manifest.SolutionId.trim() || !Array.isArray(manifest.Projects))
|
|
183
|
+
return;
|
|
184
|
+
if (!projectKey(manifest.SolutionId))
|
|
185
|
+
return;
|
|
186
|
+
const members = [];
|
|
187
|
+
for (const value of manifest.Projects) {
|
|
188
|
+
const member = record(value);
|
|
189
|
+
if (typeof member?.ProjectRelativePath !== "string" || !member.ProjectRelativePath.trim())
|
|
190
|
+
continue;
|
|
191
|
+
const relative = toPortableRelativePath2(member.ProjectRelativePath);
|
|
192
|
+
if (fs.path.isAbsolute(relative) || /^[a-z]:/i.test(relative))
|
|
193
|
+
continue;
|
|
194
|
+
const candidate = fs.path.resolve(fs.path.dirname(file), fs.path.dirname(relative));
|
|
195
|
+
if (!(await fs.stat(candidate))?.isDirectory())
|
|
196
|
+
continue;
|
|
197
|
+
if (await fs.realpath(candidate) !== directory)
|
|
198
|
+
continue;
|
|
199
|
+
if (selectedStat.isFile() && await fs.realpath(selected) !== await fs.realpath(fs.path.resolve(fs.path.dirname(file), relative)))
|
|
200
|
+
continue;
|
|
201
|
+
if (typeof member.Id !== "string" || !member.Id.trim())
|
|
202
|
+
return;
|
|
203
|
+
if (!projectKey(member.Id))
|
|
204
|
+
return;
|
|
205
|
+
members.push(member.Id);
|
|
206
|
+
}
|
|
207
|
+
if (members.length !== 1)
|
|
208
|
+
return;
|
|
209
|
+
return {
|
|
210
|
+
...solutionIdentityProperties({
|
|
211
|
+
id: manifest.SolutionId,
|
|
212
|
+
status: "resolved"
|
|
213
|
+
}),
|
|
214
|
+
[ProjectDimensions.SolutionProjectKey]: projectKey(members[0])
|
|
215
|
+
};
|
|
216
|
+
} catch (error) {
|
|
217
|
+
logger.debug(`[project-context] solution context skipped: ${error instanceof Error ? error.message : String(error)}`);
|
|
218
|
+
return;
|
|
219
|
+
}
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
// src/services/executor-tool-resolver.ts
|
|
223
|
+
var PROJECT_TYPE_TO_TOOL = new Map([
|
|
224
|
+
["Process", "rpa"],
|
|
225
|
+
["Tests", "rpa"],
|
|
226
|
+
["WebApp", "rpa"],
|
|
227
|
+
["Agent", "agent"],
|
|
228
|
+
["Api", "api-workflow"],
|
|
229
|
+
["Flow", "maestro"]
|
|
230
|
+
]);
|
|
231
|
+
var TOOL_TO_PACKAGE = new Map([
|
|
232
|
+
["rpa", "@uipath/rpa-tool"],
|
|
233
|
+
["agent", "@uipath/agent-tool"],
|
|
234
|
+
["api-workflow", "@uipath/api-workflow-tool"],
|
|
235
|
+
["maestro", "@uipath/maestro-tool"]
|
|
236
|
+
]);
|
|
237
|
+
function hasExecutorToolFor(projectType) {
|
|
238
|
+
return PROJECT_TYPE_TO_TOOL.has(projectType);
|
|
239
|
+
}
|
|
240
|
+
async function ensureExecutorTools(projectTypes) {
|
|
241
|
+
const neededTools = new Set;
|
|
242
|
+
for (const type of projectTypes) {
|
|
243
|
+
if (executorsFactoryRepository.canHandleProject(type))
|
|
244
|
+
continue;
|
|
245
|
+
const toolVerb = PROJECT_TYPE_TO_TOOL.get(type);
|
|
246
|
+
if (toolVerb) {
|
|
247
|
+
neededTools.add(toolVerb);
|
|
248
|
+
} else {
|
|
249
|
+
logger.warn(`No installable tool runs project type '${type}'. Run may fail.`);
|
|
250
|
+
}
|
|
251
|
+
}
|
|
252
|
+
for (const toolVerb of neededTools) {
|
|
253
|
+
logger.info(`Loading executor factory for '${toolVerb}' to run project types...`);
|
|
254
|
+
await ensureExecutorFactory(toolVerb, TOOL_TO_PACKAGE.get(toolVerb));
|
|
255
|
+
}
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
// src/services/jit-placement-service.ts
|
|
259
|
+
async function resolveJitPlacementAsync(deps) {
|
|
260
|
+
const [listError, listed] = await catchError(deps.listDevelopmentSessions());
|
|
261
|
+
if (listError) {
|
|
262
|
+
return {
|
|
263
|
+
reason: `Could not list this machine's Development robot sessions: ${listError.message}`
|
|
264
|
+
};
|
|
265
|
+
}
|
|
266
|
+
const usableSessions = listed.sessions.filter((session) => isUsable(session, deps.hostName));
|
|
267
|
+
const usable = usableSessions.find((session) => session.sessionId !== undefined) ?? usableSessions[0];
|
|
268
|
+
if (!usable) {
|
|
269
|
+
return {
|
|
270
|
+
reason: `No available Development robot session was found on '${deps.hostName}' ` + `(${listed.sessions.length} Development session(s) in the folder).`
|
|
271
|
+
};
|
|
272
|
+
}
|
|
273
|
+
const executionSettings = {
|
|
274
|
+
runtimeType: DEVELOPMENT_RUNTIME_TYPE,
|
|
275
|
+
machineTemplateName: usable.machineName,
|
|
276
|
+
hostMachineName: usable.hostMachineName
|
|
277
|
+
};
|
|
278
|
+
if (usable.serviceUserName) {
|
|
279
|
+
executionSettings.serviceUserName = usable.serviceUserName;
|
|
280
|
+
}
|
|
281
|
+
return {
|
|
282
|
+
placement: {
|
|
283
|
+
folderId: listed.folderId,
|
|
284
|
+
executionSettings,
|
|
285
|
+
...usable.sessionId === undefined ? {} : { machineSessionId: usable.sessionId }
|
|
286
|
+
}
|
|
287
|
+
};
|
|
288
|
+
}
|
|
289
|
+
var UNREACHABLE_STATUSES = new Set(["Disconnected", "Unknown"]);
|
|
290
|
+
function isUsable(session, hostName) {
|
|
291
|
+
if (session.isUnresponsive || !session.machineName) {
|
|
292
|
+
return false;
|
|
293
|
+
}
|
|
294
|
+
if (!isSameHost(session.hostMachineName, hostName)) {
|
|
295
|
+
return false;
|
|
296
|
+
}
|
|
297
|
+
if (session.status && UNREACHABLE_STATUSES.has(session.status)) {
|
|
298
|
+
return false;
|
|
299
|
+
}
|
|
300
|
+
if (session.maintenanceMode?.toLowerCase() === "enabled") {
|
|
301
|
+
return false;
|
|
302
|
+
}
|
|
303
|
+
if (session.runtimes === undefined) {
|
|
304
|
+
return true;
|
|
305
|
+
}
|
|
306
|
+
return session.runtimes - (session.usedRuntimes ?? 0) > 0;
|
|
307
|
+
}
|
|
308
|
+
var NETBIOS_NAME_LENGTH = 15;
|
|
309
|
+
function isSameHost(reportedHost, localHost) {
|
|
310
|
+
if (!reportedHost) {
|
|
311
|
+
return false;
|
|
312
|
+
}
|
|
313
|
+
const label = (name) => name.split(".")[0].toLowerCase();
|
|
314
|
+
const reported = label(reportedHost);
|
|
315
|
+
const local = label(localHost);
|
|
316
|
+
return reported === local || reported.length === NETBIOS_NAME_LENGTH && local.startsWith(reported);
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
// src/services/jit-policy.ts
|
|
320
|
+
var JIT_PROJECT_TYPES = new Map([
|
|
321
|
+
["Process", "Process"],
|
|
322
|
+
["Flow", "Flow"]
|
|
323
|
+
]);
|
|
324
|
+
var JIT_LEAD_ONLY_TYPES = new Set(["flow"]);
|
|
325
|
+
function isJitLeadOnlyType(manifestProjectType) {
|
|
326
|
+
return JIT_LEAD_ONLY_TYPES.has(manifestProjectType.toLowerCase());
|
|
327
|
+
}
|
|
328
|
+
function toWireProjectType(manifestProjectType) {
|
|
329
|
+
for (const [manifest, wire] of JIT_PROJECT_TYPES) {
|
|
330
|
+
if (manifest.toLowerCase() === manifestProjectType.toLowerCase()) {
|
|
331
|
+
return wire;
|
|
332
|
+
}
|
|
333
|
+
}
|
|
334
|
+
return;
|
|
335
|
+
}
|
|
336
|
+
var unreadable = [...JIT_PROJECT_TYPES.values()].filter((wire) => !ORCHESTRATOR_PROJECT_TYPES.some((known) => known.toLowerCase() === wire.toLowerCase()));
|
|
337
|
+
if (unreadable.length > 0) {
|
|
338
|
+
throw new Error(`JIT_PROJECT_TYPES maps to project types Orchestrator cannot read: ${unreadable.join(", ")}.`);
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
// src/services/jit-sessions.ts
|
|
342
|
+
async function listDevelopmentSessionsAsync(options) {
|
|
343
|
+
const workspace = await resolvePersonalWorkspace(options);
|
|
344
|
+
const folder = await resolveFolder({ folderKey: workspace.key }, options);
|
|
345
|
+
if (!folder) {
|
|
346
|
+
throw new Error(`Could not resolve the personal workspace folder '${workspace.key}' to list its robot sessions.`);
|
|
347
|
+
}
|
|
348
|
+
const config = await createOrchestratorConfig(options);
|
|
349
|
+
const api = new SessionsApi(config);
|
|
350
|
+
const sessions = [];
|
|
351
|
+
for (let page = 0;page < MAX_SESSION_PAGES; page++) {
|
|
352
|
+
const response = await api.sessionsGetMachineSessionRuntimesByFolderId({
|
|
353
|
+
folderId: folder.id,
|
|
354
|
+
runtimeType: DEVELOPMENT_RUNTIME_TYPE,
|
|
355
|
+
$top: SESSION_PAGE_SIZE,
|
|
356
|
+
$skip: page * SESSION_PAGE_SIZE
|
|
357
|
+
});
|
|
358
|
+
const rows = response.value ?? [];
|
|
359
|
+
sessions.push(...rows);
|
|
360
|
+
if (rows.length < SESSION_PAGE_SIZE) {
|
|
361
|
+
return { folderId: folder.id, sessions };
|
|
362
|
+
}
|
|
363
|
+
}
|
|
364
|
+
const probe = await api.sessionsGetMachineSessionRuntimesByFolderId({
|
|
365
|
+
folderId: folder.id,
|
|
366
|
+
runtimeType: DEVELOPMENT_RUNTIME_TYPE,
|
|
367
|
+
$top: 1,
|
|
368
|
+
$skip: MAX_SESSION_PAGES * SESSION_PAGE_SIZE
|
|
369
|
+
});
|
|
370
|
+
if ((probe.value ?? []).length === 0) {
|
|
371
|
+
return { folderId: folder.id, sessions };
|
|
372
|
+
}
|
|
373
|
+
throw new Error(`The personal workspace folder '${workspace.key}' lists more than ` + `${MAX_SESSION_PAGES * SESSION_PAGE_SIZE} Development robot sessions, so this host's session could not be found.`);
|
|
374
|
+
}
|
|
375
|
+
var SESSION_PAGE_SIZE = 100;
|
|
376
|
+
var MAX_SESSION_PAGES = 20;
|
|
377
|
+
|
|
378
|
+
// src/services/provision-debug-service.ts
|
|
379
|
+
function nextDebugVersion() {
|
|
380
|
+
return `1.0.${Math.floor(Date.now() / 1000)}`;
|
|
381
|
+
}
|
|
382
|
+
async function defaultGetSolutionBuilder(solutionDir) {
|
|
383
|
+
const services = await createResourceBuilderServices2();
|
|
384
|
+
return services.getSolutionBuilder(solutionDir, true);
|
|
385
|
+
}
|
|
386
|
+
async function provisionSolutionForDebugAsync(options, deps = {}) {
|
|
387
|
+
const listLocations = deps.listLocations ?? listSelectablePublishLocations;
|
|
388
|
+
const pack = deps.pack ?? packSolutionAsync2;
|
|
389
|
+
const publish = deps.publish ?? publishSolutionAsync2;
|
|
390
|
+
const getBuilder = deps.getSolutionBuilder ?? defaultGetSolutionBuilder;
|
|
391
|
+
const newSessionId = deps.newSessionId ?? (() => crypto.randomUUID());
|
|
392
|
+
const authOptions = {
|
|
393
|
+
tenant: options.tenant,
|
|
394
|
+
loginValidity: options.loginValidity
|
|
395
|
+
};
|
|
396
|
+
const getDebugStatus = deps.getDebugStatus ?? (async (solutionKey, debugSessionId) => {
|
|
397
|
+
const auth = await getSolutionAuthContext2(authOptions);
|
|
398
|
+
return getProjectDebugStatus2({ basePath: auth.basePath, accessToken: auth.accessToken }, solutionKey, debugSessionId);
|
|
399
|
+
});
|
|
400
|
+
logger.info("Resolving the personal workspace to deploy into...");
|
|
401
|
+
const [locationsError, locations] = await catchError(listLocations(authOptions));
|
|
402
|
+
if (locationsError) {
|
|
403
|
+
return fail(`Could not resolve a personal workspace to deploy into: ${locationsError.message}`);
|
|
404
|
+
}
|
|
405
|
+
const personal = locations.find((l) => l.isMyPersonalWorkspace);
|
|
406
|
+
if (!personal) {
|
|
407
|
+
return fail("This account has no personal workspace, so there is nowhere to deploy the solution for a debug run. " + "Ask an administrator to enable a personal workspace, or run with --no-provision-resources — " + "the run then starts without a deployment, and cross-project calls will not resolve.");
|
|
408
|
+
}
|
|
409
|
+
let packageVersionKey;
|
|
410
|
+
if (!options.resourcesOnly) {
|
|
411
|
+
const version = options.version ?? nextDebugVersion();
|
|
412
|
+
const fs = getFileSystem();
|
|
413
|
+
const outputPath = fs.path.join(fs.env.tmpdir(), "uip-solution-run", newSessionId());
|
|
414
|
+
const uploaded = await packAndUploadAsync({
|
|
415
|
+
options,
|
|
416
|
+
authOptions,
|
|
417
|
+
pack,
|
|
418
|
+
publish,
|
|
419
|
+
version,
|
|
420
|
+
outputPath
|
|
421
|
+
});
|
|
422
|
+
if (!uploaded.ok) {
|
|
423
|
+
return fail(uploaded.message);
|
|
424
|
+
}
|
|
425
|
+
packageVersionKey = uploaded.packageVersionKey;
|
|
426
|
+
} else {
|
|
427
|
+
logger.info("Provisioning the solution's resources only — its projects are resolved " + "from the run's own debug map, so nothing is packed or uploaded.");
|
|
428
|
+
}
|
|
429
|
+
logger.info("Provisioning the solution's resources for the run...");
|
|
430
|
+
const [builderError, builder] = await catchError(getBuilder(options.solutionDir));
|
|
431
|
+
if (builderError) {
|
|
432
|
+
return fail(`Could not read the solution: ${builderError.message}`);
|
|
433
|
+
}
|
|
434
|
+
const sessionId = newSessionId();
|
|
435
|
+
const [debugError, debug] = await catchError(builder.debugProjectAsync(personal.key, options.solutionName, sessionId, packageVersionKey, true));
|
|
436
|
+
let solutionKey;
|
|
437
|
+
if (!debugError && debug.complete === false) {
|
|
438
|
+
const [, definition] = await catchError(builder.context.loadAsync());
|
|
439
|
+
solutionKey = definition?.key;
|
|
440
|
+
}
|
|
441
|
+
await builder.disposeAsync().catch(() => {});
|
|
442
|
+
if (debugError) {
|
|
443
|
+
return fail(`Provisioning the solution failed: ${debugError.message}`);
|
|
444
|
+
}
|
|
445
|
+
if (debug.complete === false) {
|
|
446
|
+
if (!solutionKey) {
|
|
447
|
+
return fail("The cloud is still provisioning the solution, but its key could not be read back from the .uipx, so the provisioning cannot be waited on. Retry the run.");
|
|
448
|
+
}
|
|
449
|
+
return waitForProvisioningAsync({
|
|
450
|
+
solutionKey,
|
|
451
|
+
sessionId,
|
|
452
|
+
packageVersionKey,
|
|
453
|
+
options,
|
|
454
|
+
getDebugStatus
|
|
455
|
+
});
|
|
456
|
+
}
|
|
457
|
+
const folderPath = debug.folderFullyQualifiedName;
|
|
458
|
+
logger.info(folderPath ? `Solution provisioned into ${folderPath}.` : "Solution provisioned.");
|
|
459
|
+
return {
|
|
460
|
+
ok: true,
|
|
461
|
+
folderPath,
|
|
462
|
+
packageVersionKey
|
|
463
|
+
};
|
|
464
|
+
}
|
|
465
|
+
function fail(message) {
|
|
466
|
+
return { ok: false, message };
|
|
467
|
+
}
|
|
468
|
+
async function packAndUploadAsync(args) {
|
|
469
|
+
const { options, authOptions, version } = args;
|
|
470
|
+
logger.info("Packing the solution...");
|
|
471
|
+
const [packError, packed] = await catchError(args.pack(options.solutionDir, {
|
|
472
|
+
output: args.outputPath,
|
|
473
|
+
name: options.solutionName,
|
|
474
|
+
version,
|
|
475
|
+
loginValidity: options.loginValidity,
|
|
476
|
+
forDebug: true
|
|
477
|
+
}));
|
|
478
|
+
if (packError) {
|
|
479
|
+
return {
|
|
480
|
+
ok: false,
|
|
481
|
+
message: `Packing the solution failed: ${packError.message}`
|
|
482
|
+
};
|
|
483
|
+
}
|
|
484
|
+
if (!packed.ok) {
|
|
485
|
+
return {
|
|
486
|
+
ok: false,
|
|
487
|
+
message: `Packing the solution failed: ${packed.message}`
|
|
488
|
+
};
|
|
489
|
+
}
|
|
490
|
+
const packagePath = packed.packages?.[0];
|
|
491
|
+
if (!packagePath) {
|
|
492
|
+
return {
|
|
493
|
+
ok: false,
|
|
494
|
+
message: "Packing the solution produced no package."
|
|
495
|
+
};
|
|
496
|
+
}
|
|
497
|
+
logger.info("Uploading the solution to the personal workspace...");
|
|
498
|
+
const [publishError, published] = await catchError(args.publish(packagePath, {
|
|
499
|
+
...authOptions,
|
|
500
|
+
personalWorkspace: true,
|
|
501
|
+
packageVersion: version
|
|
502
|
+
}));
|
|
503
|
+
if (publishError) {
|
|
504
|
+
return {
|
|
505
|
+
ok: false,
|
|
506
|
+
message: `Uploading the solution failed: ${publishError.message}`
|
|
507
|
+
};
|
|
508
|
+
}
|
|
509
|
+
if (!published.ok) {
|
|
510
|
+
return {
|
|
511
|
+
ok: false,
|
|
512
|
+
message: `Uploading the solution failed: ${published.message}`
|
|
513
|
+
};
|
|
514
|
+
}
|
|
515
|
+
if (!published.packageVersionKey) {
|
|
516
|
+
return {
|
|
517
|
+
ok: false,
|
|
518
|
+
message: "The solution was uploaded but the feed did not report a package version, so it cannot be provisioned. Retry the run."
|
|
519
|
+
};
|
|
520
|
+
}
|
|
521
|
+
return { ok: true, packageVersionKey: published.packageVersionKey };
|
|
522
|
+
}
|
|
523
|
+
async function waitForProvisioningAsync(args) {
|
|
524
|
+
const { solutionKey, sessionId, packageVersionKey, options } = args;
|
|
525
|
+
const timeoutMs = options.provisioningTimeoutMs ?? 360000;
|
|
526
|
+
logger.info("Waiting for the cloud to finish provisioning...");
|
|
527
|
+
const poll = await pollUntil({
|
|
528
|
+
fn: () => args.getDebugStatus(solutionKey, sessionId),
|
|
529
|
+
until: (info) => isDebugProvisioningTerminal2(info.status),
|
|
530
|
+
getStatus: (info) => info.status ?? "pending",
|
|
531
|
+
label: `solution provisioning (session ${sessionId})`,
|
|
532
|
+
logPrefix: "provision",
|
|
533
|
+
timeoutMs,
|
|
534
|
+
intervalMs: options.provisioningPollIntervalMs ?? 5000,
|
|
535
|
+
maxConsecutiveErrors: 5,
|
|
536
|
+
signal: processContext.pollSignal
|
|
537
|
+
});
|
|
538
|
+
if (poll.outcome !== PollOutcome.Completed || !poll.data) {
|
|
539
|
+
return fail(describeIncompleteWait(poll, timeoutMs));
|
|
540
|
+
}
|
|
541
|
+
const info = poll.data;
|
|
542
|
+
if (!isDebugProvisioningSucceeded2(info.status)) {
|
|
543
|
+
const details = (info.errors ?? []).map((error) => error.resource ? `${error.resource.kind ?? "resource"} '${error.resource.name ?? error.resource.key ?? ""}': ${error.message}` : error.message).join(`
|
|
544
|
+
`);
|
|
545
|
+
return fail(`Provisioning the solution failed (${info.status}).` + (details ? `
|
|
546
|
+
${details}` : ""));
|
|
547
|
+
}
|
|
548
|
+
logger.info("Solution provisioned.");
|
|
549
|
+
return { ok: true, packageVersionKey };
|
|
550
|
+
}
|
|
551
|
+
function describeIncompleteWait(poll, timeoutMs) {
|
|
552
|
+
const lastStatus = poll.data?.status ?? "unknown";
|
|
553
|
+
if (poll.outcome === PollOutcome.Interrupted) {
|
|
554
|
+
return `The wait for the solution's provisioning was cancelled (last status: ${lastStatus}). ` + "The cloud may still finish it.";
|
|
555
|
+
}
|
|
556
|
+
if (poll.outcome === PollOutcome.Failed || poll.outcome === PollOutcome.Aborted) {
|
|
557
|
+
return `Checking the solution's provisioning status failed: ${poll.error?.message ?? "too many consecutive errors"} ` + `(last status: ${lastStatus}). The provisioning itself may still be running or have finished — ` + "retry the run to check.";
|
|
558
|
+
}
|
|
559
|
+
return `The solution was uploaded, but the cloud did not finish provisioning it within ${Math.round(timeoutMs / 1000)}s ` + `(last status: ${lastStatus}). ` + "Running again will not help: each run uploads a new version and provisions that one too. " + "To run a project that calls another project, deploy the solution once " + "('uip solution pack' → 'publish' → 'deploy run') and then run with " + "--no-provision-resources --folder-path <deployed folder>.";
|
|
560
|
+
}
|
|
561
|
+
|
|
562
|
+
// src/services/run-service.ts
|
|
563
|
+
async function captureRunMember(capture, projectPath, fileSystem) {
|
|
564
|
+
if (!capture || isProjectTelemetryDisabled())
|
|
565
|
+
return;
|
|
566
|
+
const [error, context] = await catchError(withinProjectIdentityBudget(readProjectSolutionContext(projectPath, fileSystem), () => logger.debug(`Run member telemetry skipped: no answer within ${PROJECT_IDENTITY_LOOKUP_BUDGET_MS} ms`)));
|
|
567
|
+
if (error) {
|
|
568
|
+
logger.debug(`Run member telemetry skipped: ${error.message}`);
|
|
569
|
+
return;
|
|
570
|
+
}
|
|
571
|
+
if (!context)
|
|
572
|
+
return;
|
|
573
|
+
const [captureError] = catchError(() => capture.setProperties?.(context));
|
|
574
|
+
if (captureError) {
|
|
575
|
+
logger.debug(`Run member telemetry skipped: ${captureError.message}`);
|
|
576
|
+
}
|
|
577
|
+
}
|
|
578
|
+
async function runSolutionAsync(options, deps, cancellationToken) {
|
|
579
|
+
const { fileSystem } = deps;
|
|
580
|
+
const solutionDir = fileSystem.path.resolve(options.solutionPath);
|
|
581
|
+
const lead = await selectLeadAsync(solutionDir, options.projectName, fileSystem);
|
|
582
|
+
if ("code" in lead) {
|
|
583
|
+
return RunResult.failed(lead.code, lead.message);
|
|
584
|
+
}
|
|
585
|
+
const { projects, selected } = lead;
|
|
586
|
+
const projectPath = fileSystem.path.resolve(solutionDir, selected.relativePath);
|
|
587
|
+
const provision = deps.provisionForDebug ?? provisionSolutionForDebugAsync;
|
|
588
|
+
const leadProvisionsItself = isJitLeadOnlyType(selected.projectType);
|
|
589
|
+
const shouldProvision = options.provisionResources ?? (projects.length > 1 && (!leadProvisionsItself || options.jit === true));
|
|
590
|
+
const eligibility = options.jit && shouldProvision && projects.length > 1 ? await resolveJitRunAsync(projects, selected, options, deps, {}, cancellationToken) : undefined;
|
|
591
|
+
if (eligibility && cancellationToken?.aborted) {
|
|
592
|
+
return RunResult.failed("Cancelled" /* Cancelled */, "The run was cancelled while the runners were being loaded and the process calls of the solution's projects were being listed.");
|
|
593
|
+
}
|
|
594
|
+
if (eligibility?.eligible === false) {
|
|
595
|
+
logger.info(eligibility.reason);
|
|
596
|
+
} else if (options.jit && !eligibility) {
|
|
597
|
+
logger.info(projects.length > 1 ? "--jit has no effect without provisioning, so the run takes the classic route." : "--jit has no effect on a single-project solution, which has no sibling to reach.");
|
|
598
|
+
}
|
|
599
|
+
let jit = eligibility?.eligible ? eligibility.run : undefined;
|
|
600
|
+
let fpsProperties;
|
|
601
|
+
let executorLoaded = false;
|
|
602
|
+
if (jit) {
|
|
603
|
+
const jitTypes = [...new Set(jit.projects.map((p) => p.projectType))];
|
|
604
|
+
const [executorError] = await catchError(ensureExecutorTools(jitTypes));
|
|
605
|
+
if (cancellationToken?.aborted) {
|
|
606
|
+
return RunResult.failed("Cancelled" /* Cancelled */, "The run was cancelled while the solution's runners were being loaded.");
|
|
607
|
+
}
|
|
608
|
+
if (executorError) {
|
|
609
|
+
return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not load the runners for project types ${jitTypes.map((t) => `'${t}'`).join(", ")}: ${describeError(executorError)}`);
|
|
610
|
+
}
|
|
611
|
+
executorLoaded = true;
|
|
612
|
+
const bagSession = await resolveConnection(undefined, options, deps);
|
|
613
|
+
const [prepareError, prepared] = await catchError(buildJitBagAsync(jit, selected, {
|
|
614
|
+
solutionDir,
|
|
615
|
+
solutionName: fileSystem.path.basename(solutionDir),
|
|
616
|
+
connection: {
|
|
617
|
+
...bagSession,
|
|
618
|
+
organizationUnitId: jit.placement.folderId
|
|
619
|
+
},
|
|
620
|
+
options,
|
|
621
|
+
deps,
|
|
622
|
+
cancellationToken
|
|
623
|
+
}));
|
|
624
|
+
if (cancellationToken?.aborted) {
|
|
625
|
+
return RunResult.failed("Cancelled" /* Cancelled */, "The run was cancelled while the solution's projects were being described.");
|
|
626
|
+
}
|
|
627
|
+
if (prepareError) {
|
|
628
|
+
logger.info(`Just-in-time debugging is unavailable for this solution, so it is packed and ` + `deployed as usual: ${describeError(prepareError)}`);
|
|
629
|
+
jit = undefined;
|
|
630
|
+
} else {
|
|
631
|
+
fpsProperties = prepared;
|
|
632
|
+
}
|
|
633
|
+
}
|
|
634
|
+
if (cancellationToken?.aborted) {
|
|
635
|
+
return RunResult.failed("Cancelled" /* Cancelled */, shouldProvision ? "The run was cancelled before the solution was provisioned." : "The run was cancelled before it started.");
|
|
636
|
+
}
|
|
637
|
+
const [executorOutcome, provisionOutcome] = await Promise.allSettled([
|
|
638
|
+
executorLoaded ? Promise.resolve() : ensureExecutorTools([selected.projectType]),
|
|
639
|
+
shouldProvision ? provision({
|
|
640
|
+
solutionDir,
|
|
641
|
+
solutionName: fileSystem.path.basename(solutionDir),
|
|
642
|
+
tenant: options.tenant,
|
|
643
|
+
loginValidity: options.loginValidity,
|
|
644
|
+
resourcesOnly: jit !== undefined
|
|
645
|
+
}) : Promise.resolve(undefined)
|
|
646
|
+
]);
|
|
647
|
+
await captureRunMember(deps.telemetryCapture, projectPath, fileSystem);
|
|
648
|
+
if (executorOutcome.status === "rejected") {
|
|
649
|
+
return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not load the runner for project type '${selected.projectType}': ${describeError(executorOutcome.reason)}`);
|
|
650
|
+
}
|
|
651
|
+
if (provisionOutcome.status === "rejected") {
|
|
652
|
+
return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not deploy the solution before the run: ${describeError(provisionOutcome.reason)}`);
|
|
653
|
+
}
|
|
654
|
+
let folderPath = options.folderPath;
|
|
655
|
+
const provisioned = provisionOutcome.value;
|
|
656
|
+
if (provisioned) {
|
|
657
|
+
if (!provisioned.ok) {
|
|
658
|
+
return RunResult.failed("PrepareFailed" /* PrepareFailed */, provisioned.message ?? "Could not deploy the solution before the run.");
|
|
659
|
+
}
|
|
660
|
+
folderPath = provisioned.folderPath;
|
|
661
|
+
}
|
|
662
|
+
logger.debug(`Running '${selected.name}' (${selected.projectType}) from ${projectPath}` + `${options.entryPoint ? ` with entry point ${options.entryPoint}` : " with its default entry point"}`);
|
|
663
|
+
const resolvedConnection = await resolveConnection(folderPath, options, deps);
|
|
664
|
+
const connection = jit ? { ...resolvedConnection, organizationUnitId: jit.placement.folderId } : resolvedConnection;
|
|
665
|
+
const solutionDisplayName = fileSystem.path.basename(solutionDir);
|
|
666
|
+
const runner = new ProjectRunner({
|
|
667
|
+
fileSystem,
|
|
668
|
+
logger: deps.logger
|
|
669
|
+
});
|
|
670
|
+
return runner.runAsync({
|
|
671
|
+
project: {
|
|
672
|
+
name: selected.name,
|
|
673
|
+
projectType: selected.projectType,
|
|
674
|
+
projectPath,
|
|
675
|
+
...selected.designId ? { designId: selected.designId } : {}
|
|
676
|
+
},
|
|
677
|
+
entryPoint: options.entryPoint,
|
|
678
|
+
inputArguments: options.inputArguments,
|
|
679
|
+
target: fpsProperties ? "Online" /* Online */ : "Local" /* Local */,
|
|
680
|
+
connection,
|
|
681
|
+
siblingProjects: projects.filter((p) => p !== selected).map((p) => ({
|
|
682
|
+
name: p.name,
|
|
683
|
+
projectType: p.projectType,
|
|
684
|
+
projectPath: fileSystem.path.resolve(solutionDir, p.relativePath),
|
|
685
|
+
...p.designId ? { designId: p.designId } : {}
|
|
686
|
+
})),
|
|
687
|
+
timeoutMs: options.timeoutMs,
|
|
688
|
+
...fpsProperties ? {
|
|
689
|
+
fpsProperties,
|
|
690
|
+
solutionName: solutionDisplayName,
|
|
691
|
+
...jit?.placement.machineSessionId === undefined ? {} : {
|
|
692
|
+
machineSessionId: jit.placement.machineSessionId
|
|
693
|
+
}
|
|
694
|
+
} : {}
|
|
695
|
+
}, cancellationToken);
|
|
696
|
+
}
|
|
697
|
+
async function resolveJitPropertiesAsync(options, deps, cancellationToken) {
|
|
698
|
+
const { fileSystem } = deps;
|
|
699
|
+
const solutionDir = fileSystem.path.resolve(options.solutionPath);
|
|
700
|
+
const lead = await selectLeadAsync(solutionDir, options.projectName, fileSystem);
|
|
701
|
+
if ("code" in lead) {
|
|
702
|
+
return { status: "failed", message: lead.message };
|
|
703
|
+
}
|
|
704
|
+
const { projects, selected } = lead;
|
|
705
|
+
const cancelledWhile = (phase) => ({
|
|
706
|
+
status: "cancelled",
|
|
707
|
+
message: `Resolving the JIT properties was cancelled while ${phase}.`
|
|
708
|
+
});
|
|
709
|
+
if (cancellationToken?.aborted) {
|
|
710
|
+
return cancelledWhile("the solution was being read");
|
|
711
|
+
}
|
|
712
|
+
if (projects.length < 2) {
|
|
713
|
+
return {
|
|
714
|
+
status: "notEligible",
|
|
715
|
+
reason: `Solution '${fileSystem.path.basename(solutionDir)}' holds a single project, ` + "so it has no cross-project call for a just-in-time debug map to resolve."
|
|
716
|
+
};
|
|
717
|
+
}
|
|
718
|
+
if (isJitLeadOnlyType(selected.projectType)) {
|
|
719
|
+
return {
|
|
720
|
+
status: "notEligible",
|
|
721
|
+
reason: `Project '${selected.name}' is a ${selected.projectType}, which starts through ` + "'uip solution run --jit' rather than from a caller that starts the job itself, " + "so it is packed and deployed as usual."
|
|
722
|
+
};
|
|
723
|
+
}
|
|
724
|
+
const runOptions = {
|
|
725
|
+
solutionPath: options.solutionPath,
|
|
726
|
+
projectName: options.projectName,
|
|
727
|
+
entryPoint: options.entryPoint,
|
|
728
|
+
inputArguments: options.inputArguments,
|
|
729
|
+
tenant: options.tenant,
|
|
730
|
+
loginValidity: options.loginValidity,
|
|
731
|
+
jit: true
|
|
732
|
+
};
|
|
733
|
+
const eligibility = await resolveJitRunAsync(projects, selected, runOptions, deps, { skipIneligibleProjects: options.skipIneligibleProjects }, cancellationToken);
|
|
734
|
+
if (cancellationToken?.aborted) {
|
|
735
|
+
return cancelledWhile("the process calls and this machine's Development robot sessions were being looked up");
|
|
736
|
+
}
|
|
737
|
+
if (!eligibility.eligible) {
|
|
738
|
+
return {
|
|
739
|
+
status: "notEligible",
|
|
740
|
+
reason: eligibility.reason,
|
|
741
|
+
...eligibility.skippable ? { skippableProjects: eligibility.skippable } : {},
|
|
742
|
+
...eligibility.reachable
|
|
743
|
+
};
|
|
744
|
+
}
|
|
745
|
+
const jit = eligibility.run;
|
|
746
|
+
const [toolError] = await catchError(ensureExecutorTools([
|
|
747
|
+
...new Set(jit.projects.map((p) => p.projectType))
|
|
748
|
+
]));
|
|
749
|
+
if (cancellationToken?.aborted) {
|
|
750
|
+
return cancelledWhile("the solution's runners were being loaded");
|
|
751
|
+
}
|
|
752
|
+
if (toolError) {
|
|
753
|
+
return {
|
|
754
|
+
status: "notEligible",
|
|
755
|
+
reason: `Could not load the runners that describe this solution's projects, so it is packed and deployed as usual: ${describeError(toolError)}`
|
|
756
|
+
};
|
|
757
|
+
}
|
|
758
|
+
const { machineSessionId } = jit.placement;
|
|
759
|
+
if (machineSessionId === undefined) {
|
|
760
|
+
return {
|
|
761
|
+
status: "notEligible",
|
|
762
|
+
reason: "Orchestrator reported a usable Development robot session on this machine but no " + "session id, so the lead project cannot be pinned to it."
|
|
763
|
+
};
|
|
764
|
+
}
|
|
765
|
+
const resolvedConnection = await resolveConnection(undefined, runOptions, deps);
|
|
766
|
+
const connection = {
|
|
767
|
+
...resolvedConnection,
|
|
768
|
+
organizationUnitId: jit.placement.folderId
|
|
769
|
+
};
|
|
770
|
+
const [bagError, fpsProperties] = await catchError(buildJitBagAsync(jit, selected, {
|
|
771
|
+
solutionDir,
|
|
772
|
+
solutionName: fileSystem.path.basename(solutionDir),
|
|
773
|
+
connection,
|
|
774
|
+
options: runOptions,
|
|
775
|
+
deps,
|
|
776
|
+
cancellationToken
|
|
777
|
+
}));
|
|
778
|
+
if (cancellationToken?.aborted) {
|
|
779
|
+
return cancelledWhile("the solution's projects were being described");
|
|
780
|
+
}
|
|
781
|
+
if (bagError) {
|
|
782
|
+
return { status: "notEligible", reason: bagError.message };
|
|
783
|
+
}
|
|
784
|
+
const [stripError, handover] = catchError(() => withoutLeadExecutorInfo(fpsProperties));
|
|
785
|
+
if (stripError) {
|
|
786
|
+
return { status: "failed", message: stripError.message };
|
|
787
|
+
}
|
|
788
|
+
return {
|
|
789
|
+
status: "ready",
|
|
790
|
+
fpsProperties: handover,
|
|
791
|
+
folderId: jit.placement.folderId,
|
|
792
|
+
machineSessionIds: [machineSessionId],
|
|
793
|
+
...jit.skipped.length > 0 ? { skippedProjects: jit.skipped } : {},
|
|
794
|
+
...jit.reachable
|
|
795
|
+
};
|
|
796
|
+
}
|
|
797
|
+
function withoutLeadExecutorInfo(fpsProperties) {
|
|
798
|
+
const bag = JSON.parse(fpsProperties);
|
|
799
|
+
delete bag[FPS_DEBUG_EXECUTOR];
|
|
800
|
+
return JSON.stringify(bag);
|
|
801
|
+
}
|
|
802
|
+
async function resolveConnection(folderPath, options, deps) {
|
|
803
|
+
const getLoginStatus = deps.getLoginStatus ?? getLoginStatusAsync;
|
|
804
|
+
const [loginError, status] = await catchError(getLoginStatus({
|
|
805
|
+
ensureTokenValidityMinutes: options.loginValidity
|
|
806
|
+
}));
|
|
807
|
+
if (loginError || status?.loginStatus !== "Logged in") {
|
|
808
|
+
logger.debug(`No signed-in session for the run: ${loginError?.message ?? status?.loginStatus}. ` + "A project type that needs one will say so.");
|
|
809
|
+
return {
|
|
810
|
+
folderPath,
|
|
811
|
+
baseUrl: "",
|
|
812
|
+
accessToken: "",
|
|
813
|
+
organizationId: "",
|
|
814
|
+
organizationName: ""
|
|
815
|
+
};
|
|
816
|
+
}
|
|
817
|
+
const tenantName = options.tenant || status.tenantName;
|
|
818
|
+
const isSessionTenant = tenantName?.toLowerCase() === status.tenantName?.toLowerCase();
|
|
819
|
+
return {
|
|
820
|
+
folderPath,
|
|
821
|
+
baseUrl: status.baseUrl ?? "",
|
|
822
|
+
accessToken: status.accessToken ?? "",
|
|
823
|
+
organizationId: status.organizationId ?? "",
|
|
824
|
+
organizationName: status.organizationName ?? "",
|
|
825
|
+
tenantId: isSessionTenant ? status.tenantId : undefined,
|
|
826
|
+
tenantName
|
|
827
|
+
};
|
|
828
|
+
}
|
|
829
|
+
function jitSiblingWireType(project) {
|
|
830
|
+
if (isJitLeadOnlyType(project.projectType)) {
|
|
831
|
+
return {
|
|
832
|
+
ineligibility: `Project '${project.name}' has type '${project.projectType}', which takes part in a ` + "just-in-time run only as the lead project",
|
|
833
|
+
leadOnly: true
|
|
834
|
+
};
|
|
835
|
+
}
|
|
836
|
+
const wireType = toWireProjectType(project.projectType);
|
|
837
|
+
if (!wireType) {
|
|
838
|
+
return {
|
|
839
|
+
ineligibility: `Project '${project.name}' has type '${project.projectType}', which is not ` + "onboarded for just-in-time debugging",
|
|
840
|
+
leadOnly: false
|
|
841
|
+
};
|
|
842
|
+
}
|
|
843
|
+
return { wireType };
|
|
844
|
+
}
|
|
845
|
+
async function resolveJitRunAsync(projects, selected, options, deps, policy = {}, cancellationToken) {
|
|
846
|
+
const fallback = ", so the whole solution is packed and deployed as usual.";
|
|
847
|
+
const leadWireType = toWireProjectType(selected.projectType);
|
|
848
|
+
if (!leadWireType) {
|
|
849
|
+
return {
|
|
850
|
+
eligible: false,
|
|
851
|
+
reason: `Project '${selected.name}' has type '${selected.projectType}', which is not ` + `onboarded for just-in-time debugging${fallback}`
|
|
852
|
+
};
|
|
853
|
+
}
|
|
854
|
+
const placed = await resolveJitPlacementAsync({
|
|
855
|
+
hostName: hostname(),
|
|
856
|
+
listDevelopmentSessions: deps.listDevelopmentSessions ?? (() => listDevelopmentSessionsAsync({
|
|
857
|
+
tenant: options.tenant,
|
|
858
|
+
loginValidity: options.loginValidity
|
|
859
|
+
}))
|
|
860
|
+
});
|
|
861
|
+
if ("reason" in placed) {
|
|
862
|
+
return {
|
|
863
|
+
eligible: false,
|
|
864
|
+
reason: "The solution's projects cannot be pinned to this machine, so it is packed and " + `deployed as usual: ${placed.reason}`
|
|
865
|
+
};
|
|
866
|
+
}
|
|
867
|
+
const { placement } = placed;
|
|
868
|
+
if (placement.machineSessionId === undefined && !isJitLeadOnlyType(selected.projectType)) {
|
|
869
|
+
return {
|
|
870
|
+
eligible: false,
|
|
871
|
+
reason: "Orchestrator reported a usable Development robot session on this machine but no " + "session id, so the lead project cannot be pinned to it and the solution is " + "packed and deployed as usual."
|
|
872
|
+
};
|
|
873
|
+
}
|
|
874
|
+
const { candidates, reachable } = await findReachableProjectsAsync(projects, selected, options, deps, cancellationToken);
|
|
875
|
+
if (cancellationToken?.aborted) {
|
|
876
|
+
return {
|
|
877
|
+
eligible: false,
|
|
878
|
+
reason: "The process calls were being listed when the request was cancelled."
|
|
879
|
+
};
|
|
880
|
+
}
|
|
881
|
+
const included = [selected];
|
|
882
|
+
const wireTypes = new Map([[selected.projectType, leadWireType]]);
|
|
883
|
+
const ineligibilities = [];
|
|
884
|
+
const skipped = [];
|
|
885
|
+
for (const project of candidates) {
|
|
886
|
+
if (project === selected) {
|
|
887
|
+
continue;
|
|
888
|
+
}
|
|
889
|
+
const verdict = jitSiblingWireType(project);
|
|
890
|
+
if ("wireType" in verdict) {
|
|
891
|
+
included.push(project);
|
|
892
|
+
wireTypes.set(project.projectType, verdict.wireType);
|
|
893
|
+
} else {
|
|
894
|
+
ineligibilities.push(verdict);
|
|
895
|
+
skipped.push({
|
|
896
|
+
name: project.name,
|
|
897
|
+
reason: `${verdict.ineligibility}.`
|
|
898
|
+
});
|
|
899
|
+
}
|
|
900
|
+
}
|
|
901
|
+
const firstIneligibility = (ineligibilities.find((verdict) => verdict.leadOnly) ?? ineligibilities[0])?.ineligibility;
|
|
902
|
+
if (firstIneligibility && !policy.skipIneligibleProjects) {
|
|
903
|
+
return {
|
|
904
|
+
eligible: false,
|
|
905
|
+
reason: `${firstIneligibility}${fallback}`,
|
|
906
|
+
...included.length > 1 ? { skippable: skipped } : {},
|
|
907
|
+
reachable
|
|
908
|
+
};
|
|
909
|
+
}
|
|
910
|
+
if (included.length < 2 && skipped.length > 0) {
|
|
911
|
+
return {
|
|
912
|
+
eligible: false,
|
|
913
|
+
reason: "Every other project in the solution is skipped, so no cross-project call is " + "left for a just-in-time debug map to resolve.",
|
|
914
|
+
reachable
|
|
915
|
+
};
|
|
916
|
+
}
|
|
917
|
+
return {
|
|
918
|
+
eligible: true,
|
|
919
|
+
run: { projects: included, skipped, reachable, wireTypes, placement }
|
|
920
|
+
};
|
|
921
|
+
}
|
|
922
|
+
async function findReachableProjectsAsync(projects, selected, options, deps, cancellationToken) {
|
|
923
|
+
const { fileSystem } = deps;
|
|
924
|
+
const solutionDir = fileSystem.path.resolve(options.solutionPath);
|
|
925
|
+
const collector = new JitEntryCollector({
|
|
926
|
+
fileSystem,
|
|
927
|
+
logger: deps.logger
|
|
928
|
+
});
|
|
929
|
+
const [graphError, graph] = await catchError(resolveReachableProjectsAsync({
|
|
930
|
+
projects,
|
|
931
|
+
lead: selected,
|
|
932
|
+
callsOf: (project) => listProcessCallsAsync(project, project === selected, solutionDir, collector, deps, cancellationToken),
|
|
933
|
+
cancellationToken
|
|
934
|
+
}));
|
|
935
|
+
if (cancellationToken?.aborted) {
|
|
936
|
+
return { candidates: projects, reachable: {} };
|
|
937
|
+
}
|
|
938
|
+
const reached = graph?.projects ?? projects;
|
|
939
|
+
const reachableReason = graph?.keptAll?.message ?? (graphError ? `The process calls could not be walked: ${graphError.message}. Every project of the solution takes part.` : undefined);
|
|
940
|
+
const others = reached.filter((project) => project !== selected);
|
|
941
|
+
logger.info(reachableReason ?? `Project '${selected.name}' reaches ${others.map((project) => `'${project.name}'`).join(", ") || "no other project"} through its process calls.`);
|
|
942
|
+
return {
|
|
943
|
+
candidates: [selected, ...others],
|
|
944
|
+
reachable: {
|
|
945
|
+
reachableProjects: [selected.name, ...others.map((p) => p.name)],
|
|
946
|
+
...reachableReason ? { reachableReason } : {}
|
|
947
|
+
}
|
|
948
|
+
};
|
|
949
|
+
}
|
|
950
|
+
async function listProcessCallsAsync(project, isLead, solutionDir, collector, deps, cancellationToken) {
|
|
951
|
+
if (!isLead) {
|
|
952
|
+
const verdict = jitSiblingWireType(project);
|
|
953
|
+
if (!("wireType" in verdict)) {
|
|
954
|
+
return {
|
|
955
|
+
status: "unknown",
|
|
956
|
+
reason: `${verdict.ineligibility}, so its runner is not loaded`
|
|
957
|
+
};
|
|
958
|
+
}
|
|
959
|
+
}
|
|
960
|
+
if (hasExecutorToolFor(project.projectType)) {
|
|
961
|
+
await ensureExecutorTools([project.projectType]);
|
|
962
|
+
}
|
|
963
|
+
return collector.collectProcessCallsAsync({
|
|
964
|
+
name: project.name,
|
|
965
|
+
projectType: project.projectType,
|
|
966
|
+
projectPath: deps.fileSystem.path.resolve(solutionDir, project.relativePath),
|
|
967
|
+
...project.designId ? { designId: project.designId } : {}
|
|
968
|
+
}, cancellationToken);
|
|
969
|
+
}
|
|
970
|
+
async function buildJitBagAsync(jit, selected, ctx) {
|
|
971
|
+
const { fileSystem } = ctx.deps;
|
|
972
|
+
const collector = new JitEntryCollector({
|
|
973
|
+
fileSystem,
|
|
974
|
+
logger: ctx.deps.logger
|
|
975
|
+
});
|
|
976
|
+
const contextFor = (project, role) => ({
|
|
977
|
+
project: {
|
|
978
|
+
name: project.name,
|
|
979
|
+
projectType: jit.wireTypes.get(project.projectType) ?? project.projectType,
|
|
980
|
+
projectPath: fileSystem.path.resolve(ctx.solutionDir, project.relativePath),
|
|
981
|
+
...project.designId ? { designId: project.designId } : {}
|
|
982
|
+
},
|
|
983
|
+
isLead: role === "lead",
|
|
984
|
+
solutionName: ctx.solutionName,
|
|
985
|
+
connection: ctx.connection,
|
|
986
|
+
...role === "lead" && isJitLeadOnlyType(project.projectType) ? {} : { placement: jit.placement.executionSettings },
|
|
987
|
+
...role === "lead" && ctx.options.entryPoint ? { entryPoint: ctx.options.entryPoint } : {},
|
|
988
|
+
...role === "lead" && ctx.options.inputArguments ? { inputArguments: ctx.options.inputArguments } : {}
|
|
989
|
+
});
|
|
990
|
+
const leadEntries = await collector.collectAsync(contextFor(selected, "lead"), ctx.cancellationToken);
|
|
991
|
+
const [leadEntry, ...extraLeadEntries] = leadEntries;
|
|
992
|
+
const siblingEntries = [...extraLeadEntries];
|
|
993
|
+
for (const project of jit.projects) {
|
|
994
|
+
if (project === selected) {
|
|
995
|
+
continue;
|
|
996
|
+
}
|
|
997
|
+
siblingEntries.push(...await collector.collectAsync(contextFor(project, "sibling"), ctx.cancellationToken));
|
|
998
|
+
}
|
|
999
|
+
return assembleJitFpsProperties({
|
|
1000
|
+
leadEntry,
|
|
1001
|
+
siblingEntries,
|
|
1002
|
+
solutionName: ctx.solutionName
|
|
1003
|
+
});
|
|
1004
|
+
}
|
|
1005
|
+
function describeError(reason) {
|
|
1006
|
+
const message = reason instanceof Error ? reason.message : String(reason);
|
|
1007
|
+
const instructions = carriedInstructions(reason);
|
|
1008
|
+
return instructions ? `${message} ${instructions}` : message;
|
|
1009
|
+
}
|
|
1010
|
+
async function selectLeadAsync(solutionDir, projectName, fileSystem) {
|
|
1011
|
+
const [readError, projects] = await catchError(readSolutionProjects(solutionDir, fileSystem));
|
|
1012
|
+
if (readError) {
|
|
1013
|
+
return { code: "InvalidInput" /* InvalidInput */, message: readError.message };
|
|
1014
|
+
}
|
|
1015
|
+
const runnable = projects.filter((p) => hasExecutorToolFor(p.projectType));
|
|
1016
|
+
if (runnable.length === 0) {
|
|
1017
|
+
const seen = projects.map((p) => `${p.name} (${p.projectType})`).join(", ") || "none";
|
|
1018
|
+
return {
|
|
1019
|
+
code: "UnsupportedProjectType" /* UnsupportedProjectType */,
|
|
1020
|
+
message: `No project in this solution can be run. Projects: ${seen}.`
|
|
1021
|
+
};
|
|
1022
|
+
}
|
|
1023
|
+
const [selectionError, selected] = selectProject(runnable, projectName);
|
|
1024
|
+
if (selectionError) {
|
|
1025
|
+
return { code: "InvalidInput" /* InvalidInput */, message: selectionError };
|
|
1026
|
+
}
|
|
1027
|
+
return { projects, selected };
|
|
1028
|
+
}
|
|
1029
|
+
function selectProject(runnable, requested) {
|
|
1030
|
+
if (requested) {
|
|
1031
|
+
const match = runnable.find((p) => p.name === requested);
|
|
1032
|
+
if (!match) {
|
|
1033
|
+
const names = runnable.map((p) => p.name).join(", ");
|
|
1034
|
+
return [
|
|
1035
|
+
`Project '${requested}' is not a runnable project in this solution. Runnable projects: ${names}.`,
|
|
1036
|
+
runnable[0]
|
|
1037
|
+
];
|
|
1038
|
+
}
|
|
1039
|
+
return [undefined, match];
|
|
1040
|
+
}
|
|
1041
|
+
if (runnable.length > 1) {
|
|
1042
|
+
const names = runnable.map((p) => p.name).join(", ");
|
|
1043
|
+
return [
|
|
1044
|
+
`This solution has more than one runnable project, so one has to be named with --project-name. Runnable projects: ${names}.`,
|
|
1045
|
+
runnable[0]
|
|
1046
|
+
];
|
|
1047
|
+
}
|
|
1048
|
+
return [undefined, runnable[0]];
|
|
1049
|
+
}
|
|
1050
|
+
export {
|
|
1051
|
+
resolveJitPropertiesAsync,
|
|
1052
|
+
runSolutionAsync
|
|
1053
|
+
};
|
|
1054
|
+
|
|
1055
|
+
//# debugId=607B076DDCFCF94F64756E2164756E21
|