@midscene/harmony 1.17.8-beta-20261106101231.0 → 1.17.8
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/es/140.mjs +100 -0
- package/dist/es/380.mjs +185 -0
- package/dist/es/430.mjs +112 -0
- package/dist/es/600.mjs +1139 -0
- package/dist/es/bin.mjs +3 -1381
- package/dist/es/cli.mjs +3 -1318
- package/dist/es/index.mjs +5 -1502
- package/dist/es/test-runner.mjs +1 -100
- package/dist/lib/bin.js +29 -0
- package/dist/lib/cli.js +30 -1
- package/dist/lib/index.js +30 -1
- package/dist/lib/test-runner.js +1 -1
- package/dist/types/index.d.ts +1 -0
- package/package.json +5 -5
- package/static/index.html +1 -1
- package/static/static/js/208.eb5899a1.js +314 -0
- package/static/static/js/{998.dbb78266.js.LICENSE.txt → 208.eb5899a1.js.LICENSE.txt} +0 -2
- package/static/static/js/208.eb5899a1.js.map +1 -0
- package/static/static/js/async/195.430205e7.js +3 -0
- package/static/static/js/async/{195.beaced02.js.map → 195.430205e7.js.map} +1 -1
- package/static/static/js/async/236.e8e04e6d.js +2 -0
- package/static/static/js/async/{236.a5d2c1b1.js.map → 236.e8e04e6d.js.map} +1 -1
- package/static/static/js/index.adbc3a23.js +887 -0
- package/static/static/js/index.adbc3a23.js.map +1 -0
- package/static/static/js/lib-react.d4684574.js +3 -0
- package/static/static/js/{lib-react.8bb5dc6e.js.map → lib-react.d4684574.js.map} +1 -1
- package/static/static/js/998.dbb78266.js +0 -315
- package/static/static/js/998.dbb78266.js.map +0 -1
- package/static/static/js/async/195.beaced02.js +0 -3
- package/static/static/js/async/236.a5d2c1b1.js +0 -2
- package/static/static/js/index.dced2504.js +0 -887
- package/static/static/js/index.dced2504.js.map +0 -1
- package/static/static/js/lib-react.8bb5dc6e.js +0 -3
- /package/static/static/js/{index.dced2504.js.LICENSE.txt → index.adbc3a23.js.LICENSE.txt} +0 -0
- /package/static/static/js/{lib-react.8bb5dc6e.js.LICENSE.txt → lib-react.d4684574.js.LICENSE.txt} +0 -0
package/dist/es/140.mjs
ADDED
|
@@ -0,0 +1,100 @@
|
|
|
1
|
+
import { createAgentTestRunnerNodeDefinition } from "@midscene/core/agent/test";
|
|
2
|
+
import { z } from "zod/v4";
|
|
3
|
+
const defineHarmonyAgentNode = createAgentTestRunnerNodeDefinition('a Harmony Agent');
|
|
4
|
+
const nonBlankText = (description)=>z.string().regex(/\S/, 'value must contain a non-whitespace character').describe(description);
|
|
5
|
+
const launchInputSchema = z.strictObject({
|
|
6
|
+
uri: nonBlankText('The app, URL, URI, bundle name, or bundle/Ability target to launch.')
|
|
7
|
+
});
|
|
8
|
+
const terminateInputSchema = z.strictObject({
|
|
9
|
+
uri: nonBlankText('The bundle name or app name to terminate.')
|
|
10
|
+
});
|
|
11
|
+
const runHdcShellInputSchema = z.strictObject({
|
|
12
|
+
command: nonBlankText('The shell command to execute, without an hdc shell prefix.')
|
|
13
|
+
});
|
|
14
|
+
const emptyInputSchema = z.strictObject({});
|
|
15
|
+
const launchNode = defineHarmonyAgentNode({
|
|
16
|
+
method: 'launch',
|
|
17
|
+
description: 'Launch an application through the current Harmony Agent.',
|
|
18
|
+
stringInputKey: 'uri',
|
|
19
|
+
inputSchema: launchInputSchema,
|
|
20
|
+
toArgs: (input)=>[
|
|
21
|
+
input.uri
|
|
22
|
+
],
|
|
23
|
+
toResult: (_output, input)=>({
|
|
24
|
+
summary: `Launched ${input.uri}`
|
|
25
|
+
})
|
|
26
|
+
});
|
|
27
|
+
const terminateNode = defineHarmonyAgentNode({
|
|
28
|
+
method: 'terminate',
|
|
29
|
+
description: 'Terminate an application through the current Harmony Agent.',
|
|
30
|
+
stringInputKey: 'uri',
|
|
31
|
+
inputSchema: terminateInputSchema,
|
|
32
|
+
toArgs: (input)=>[
|
|
33
|
+
input.uri
|
|
34
|
+
],
|
|
35
|
+
toResult: (_output, input)=>({
|
|
36
|
+
summary: `Terminated ${input.uri}`
|
|
37
|
+
})
|
|
38
|
+
});
|
|
39
|
+
const runHdcShellNode = defineHarmonyAgentNode({
|
|
40
|
+
method: 'runHdcShell',
|
|
41
|
+
title: 'Run an HDC shell command',
|
|
42
|
+
description: 'Execute a shell command through the current Harmony Agent. Pass only the shell command, without the hdc shell prefix.',
|
|
43
|
+
stringInputKey: 'command',
|
|
44
|
+
inputSchema: runHdcShellInputSchema,
|
|
45
|
+
toArgs (input, context) {
|
|
46
|
+
context.signal.throwIfAborted();
|
|
47
|
+
if (/^\s*hdc(?:\s|$)/i.test(input.command)) throw new TypeError('command must not include an hdc or hdc shell prefix.');
|
|
48
|
+
return [
|
|
49
|
+
input.command
|
|
50
|
+
];
|
|
51
|
+
},
|
|
52
|
+
toResult (stdout) {
|
|
53
|
+
if ('string' != typeof stdout) throw new TypeError('runHdcShell() must return stdout as a string.');
|
|
54
|
+
return {
|
|
55
|
+
summary: `Executed HDC shell command (${stdout.length} stdout characters)`,
|
|
56
|
+
data: {
|
|
57
|
+
stdout
|
|
58
|
+
}
|
|
59
|
+
};
|
|
60
|
+
}
|
|
61
|
+
});
|
|
62
|
+
const backNode = defineHarmonyAgentNode({
|
|
63
|
+
method: 'back',
|
|
64
|
+
description: 'Trigger the Harmony system back operation.',
|
|
65
|
+
stringInputKey: false,
|
|
66
|
+
inputSchema: emptyInputSchema,
|
|
67
|
+
toArgs: ()=>[],
|
|
68
|
+
toResult: ()=>({
|
|
69
|
+
summary: 'Triggered Harmony back'
|
|
70
|
+
})
|
|
71
|
+
});
|
|
72
|
+
const homeNode = defineHarmonyAgentNode({
|
|
73
|
+
method: 'home',
|
|
74
|
+
description: 'Trigger the Harmony system home operation.',
|
|
75
|
+
stringInputKey: false,
|
|
76
|
+
inputSchema: emptyInputSchema,
|
|
77
|
+
toArgs: ()=>[],
|
|
78
|
+
toResult: ()=>({
|
|
79
|
+
summary: 'Triggered Harmony home'
|
|
80
|
+
})
|
|
81
|
+
});
|
|
82
|
+
const recentAppsNode = defineHarmonyAgentNode({
|
|
83
|
+
method: 'recentApps',
|
|
84
|
+
description: 'Trigger the Harmony system recent apps operation.',
|
|
85
|
+
stringInputKey: false,
|
|
86
|
+
inputSchema: emptyInputSchema,
|
|
87
|
+
toArgs: ()=>[],
|
|
88
|
+
toResult: ()=>({
|
|
89
|
+
summary: 'Triggered Harmony recentApps'
|
|
90
|
+
})
|
|
91
|
+
});
|
|
92
|
+
const harmonyAgentTestRunnerNodeDefinitions = [
|
|
93
|
+
launchNode,
|
|
94
|
+
terminateNode,
|
|
95
|
+
runHdcShellNode,
|
|
96
|
+
backNode,
|
|
97
|
+
homeNode,
|
|
98
|
+
recentAppsNode
|
|
99
|
+
];
|
|
100
|
+
export { harmonyAgentTestRunnerNodeDefinitions, launchInputSchema, runHdcShellInputSchema, terminateInputSchema };
|
package/dist/es/380.mjs
ADDED
|
@@ -0,0 +1,185 @@
|
|
|
1
|
+
import node_path from "node:path";
|
|
2
|
+
import { select as prompts_select } from "@inquirer/prompts";
|
|
3
|
+
import { createScreenshotPreviewDescriptor, definePlaygroundPlatform, launchPreparedPlaygroundPlatform } from "@midscene/playground";
|
|
4
|
+
import { PLAYGROUND_SERVER_PORT } from "@midscene/shared/constants";
|
|
5
|
+
import { findAvailablePort } from "@midscene/shared/node";
|
|
6
|
+
import { HarmonyAgent, HarmonyDevice, getConnectedDevices } from "./600.mjs";
|
|
7
|
+
const HARMONY_NO_DEVICE_MESSAGE = 'No HarmonyOS devices found. Connect a device via USB, ensure HDC is configured, and run `hdc list targets` to verify.';
|
|
8
|
+
function createNoDeviceError() {
|
|
9
|
+
return new Error(HARMONY_NO_DEVICE_MESSAGE);
|
|
10
|
+
}
|
|
11
|
+
async function getHdcTargets() {
|
|
12
|
+
const devices = await getConnectedDevices();
|
|
13
|
+
return devices.map((device, index)=>({
|
|
14
|
+
id: device.deviceId,
|
|
15
|
+
label: device.deviceId,
|
|
16
|
+
isDefault: 0 === index,
|
|
17
|
+
status: 'device'
|
|
18
|
+
}));
|
|
19
|
+
}
|
|
20
|
+
async function getHdcTargetsSafe() {
|
|
21
|
+
try {
|
|
22
|
+
const targets = await getHdcTargets();
|
|
23
|
+
return {
|
|
24
|
+
targets
|
|
25
|
+
};
|
|
26
|
+
} catch (error) {
|
|
27
|
+
return {
|
|
28
|
+
targets: [],
|
|
29
|
+
error: error instanceof Error ? error.message : String(error)
|
|
30
|
+
};
|
|
31
|
+
}
|
|
32
|
+
}
|
|
33
|
+
async function selectDevice() {
|
|
34
|
+
console.log('🔍 Scanning for HarmonyOS devices...');
|
|
35
|
+
const targets = await getHdcTargets();
|
|
36
|
+
if (0 === targets.length) throw createNoDeviceError();
|
|
37
|
+
if (1 === targets.length) {
|
|
38
|
+
console.log(`📱 Found device: ${targets[0].id}`);
|
|
39
|
+
return targets[0].id;
|
|
40
|
+
}
|
|
41
|
+
return prompts_select({
|
|
42
|
+
message: '📱 Multiple devices found. Please select one:',
|
|
43
|
+
choices: targets.map((target)=>({
|
|
44
|
+
name: target.label,
|
|
45
|
+
value: target.id
|
|
46
|
+
}))
|
|
47
|
+
});
|
|
48
|
+
}
|
|
49
|
+
const harmonyPlaygroundPlatform = definePlaygroundPlatform({
|
|
50
|
+
id: 'harmony',
|
|
51
|
+
title: 'Midscene HarmonyOS Playground',
|
|
52
|
+
description: "HarmonyOS playground platform descriptor",
|
|
53
|
+
async prepare (options) {
|
|
54
|
+
const staticDir = options?.staticDir || node_path.join(__dirname, '../../static');
|
|
55
|
+
const availablePort = await findAvailablePort(PLAYGROUND_SERVER_PORT);
|
|
56
|
+
if (availablePort !== PLAYGROUND_SERVER_PORT) console.log(`⚠️ Port ${PLAYGROUND_SERVER_PORT} is busy, using port ${availablePort} instead`);
|
|
57
|
+
const createSessionManager = ()=>({
|
|
58
|
+
async getSetupSchema () {
|
|
59
|
+
const explicitDeviceId = options?.deviceId;
|
|
60
|
+
const discovery = explicitDeviceId ? {
|
|
61
|
+
targets: [
|
|
62
|
+
{
|
|
63
|
+
id: explicitDeviceId,
|
|
64
|
+
label: explicitDeviceId,
|
|
65
|
+
isDefault: true,
|
|
66
|
+
status: 'device'
|
|
67
|
+
}
|
|
68
|
+
]
|
|
69
|
+
} : await getHdcTargetsSafe();
|
|
70
|
+
const { error, targets } = discovery;
|
|
71
|
+
return {
|
|
72
|
+
title: 'Welcome to\nMidscene.js Playground!',
|
|
73
|
+
description: 'Select an available HDC device to create the current HarmonyOS Agent',
|
|
74
|
+
primaryActionLabel: 'Create Agent',
|
|
75
|
+
autoSubmitWhenReady: 1 === targets.length,
|
|
76
|
+
notice: error ? {
|
|
77
|
+
type: 'warning',
|
|
78
|
+
message: 'HarmonyOS device discovery failed',
|
|
79
|
+
description: error
|
|
80
|
+
} : void 0,
|
|
81
|
+
fields: [
|
|
82
|
+
{
|
|
83
|
+
key: 'deviceId',
|
|
84
|
+
label: 'HDC device',
|
|
85
|
+
type: 'select',
|
|
86
|
+
required: true,
|
|
87
|
+
options: targets.map((target)=>({
|
|
88
|
+
label: target.label,
|
|
89
|
+
value: target.id,
|
|
90
|
+
description: target.description
|
|
91
|
+
})),
|
|
92
|
+
defaultValue: targets.find((target)=>target.isDefault)?.id,
|
|
93
|
+
placeholder: 'Select a connected HarmonyOS device'
|
|
94
|
+
}
|
|
95
|
+
],
|
|
96
|
+
targets
|
|
97
|
+
};
|
|
98
|
+
},
|
|
99
|
+
async listTargets () {
|
|
100
|
+
if (options?.deviceId) return [
|
|
101
|
+
{
|
|
102
|
+
id: options.deviceId,
|
|
103
|
+
label: options.deviceId,
|
|
104
|
+
isDefault: true,
|
|
105
|
+
status: 'device'
|
|
106
|
+
}
|
|
107
|
+
];
|
|
108
|
+
return (await getHdcTargetsSafe()).targets;
|
|
109
|
+
},
|
|
110
|
+
async createSession (input) {
|
|
111
|
+
const targets = options?.deviceId ? [
|
|
112
|
+
{
|
|
113
|
+
id: options.deviceId,
|
|
114
|
+
label: options.deviceId,
|
|
115
|
+
isDefault: true,
|
|
116
|
+
status: 'device'
|
|
117
|
+
}
|
|
118
|
+
] : await getHdcTargets();
|
|
119
|
+
const deviceId = options?.deviceId || ('string' == typeof input?.deviceId && input.deviceId ? input.deviceId : targets.find((target)=>target.isDefault)?.id);
|
|
120
|
+
if (!deviceId) throw createNoDeviceError();
|
|
121
|
+
const connectAgent = async ()=>{
|
|
122
|
+
const device = new HarmonyDevice(deviceId);
|
|
123
|
+
await device.connect();
|
|
124
|
+
return new HarmonyAgent(device, options?.getAgentOptions?.());
|
|
125
|
+
};
|
|
126
|
+
const agent = await connectAgent();
|
|
127
|
+
return {
|
|
128
|
+
agent,
|
|
129
|
+
agentFactory: connectAgent,
|
|
130
|
+
preview: createScreenshotPreviewDescriptor({
|
|
131
|
+
title: 'HarmonyOS device preview'
|
|
132
|
+
}),
|
|
133
|
+
displayName: deviceId,
|
|
134
|
+
metadata: {
|
|
135
|
+
deviceId
|
|
136
|
+
}
|
|
137
|
+
};
|
|
138
|
+
}
|
|
139
|
+
});
|
|
140
|
+
if (options?.deferConnection) return {
|
|
141
|
+
platformId: 'harmony',
|
|
142
|
+
title: 'Midscene HarmonyOS Playground',
|
|
143
|
+
sessionManager: createSessionManager(),
|
|
144
|
+
launchOptions: {
|
|
145
|
+
port: availablePort,
|
|
146
|
+
openBrowser: false,
|
|
147
|
+
verbose: false,
|
|
148
|
+
staticPath: staticDir
|
|
149
|
+
},
|
|
150
|
+
preview: createScreenshotPreviewDescriptor({
|
|
151
|
+
title: 'HarmonyOS device preview'
|
|
152
|
+
}),
|
|
153
|
+
metadata: {
|
|
154
|
+
...options.deviceId ? {
|
|
155
|
+
deviceId: options.deviceId
|
|
156
|
+
} : {},
|
|
157
|
+
sessionConnected: false,
|
|
158
|
+
setupState: 'required'
|
|
159
|
+
}
|
|
160
|
+
};
|
|
161
|
+
const selectedDeviceId = options?.deviceId || await selectDevice();
|
|
162
|
+
return {
|
|
163
|
+
platformId: 'harmony',
|
|
164
|
+
title: 'Midscene HarmonyOS Playground',
|
|
165
|
+
agentFactory: async ()=>{
|
|
166
|
+
const device = new HarmonyDevice(selectedDeviceId);
|
|
167
|
+
await device.connect();
|
|
168
|
+
return new HarmonyAgent(device, options?.getAgentOptions?.());
|
|
169
|
+
},
|
|
170
|
+
launchOptions: {
|
|
171
|
+
port: availablePort,
|
|
172
|
+
openBrowser: false,
|
|
173
|
+
verbose: false,
|
|
174
|
+
staticPath: staticDir
|
|
175
|
+
},
|
|
176
|
+
preview: createScreenshotPreviewDescriptor({
|
|
177
|
+
title: 'HarmonyOS device preview'
|
|
178
|
+
}),
|
|
179
|
+
metadata: {
|
|
180
|
+
deviceId: selectedDeviceId
|
|
181
|
+
}
|
|
182
|
+
};
|
|
183
|
+
}
|
|
184
|
+
});
|
|
185
|
+
export { harmonyPlaygroundPlatform, launchPreparedPlaygroundPlatform, node_path };
|
package/dist/es/430.mjs
ADDED
|
@@ -0,0 +1,112 @@
|
|
|
1
|
+
import { agentBehaviorInitArgShape, extractAgentBehaviorInitArgs, getAgentInitArgsSignature, shouldRebuildAgentForInitArgs } from "@midscene/shared/agent-tools/agent-behavior-init-args";
|
|
2
|
+
import { BaseMidsceneTools } from "@midscene/shared/agent-tools/base-tools";
|
|
3
|
+
import { HarmonyDevice, agentFromHdcDevice, z, getDebug } from "./600.mjs";
|
|
4
|
+
function _define_property(obj, key, value) {
|
|
5
|
+
if (key in obj) Object.defineProperty(obj, key, {
|
|
6
|
+
value: value,
|
|
7
|
+
enumerable: true,
|
|
8
|
+
configurable: true,
|
|
9
|
+
writable: true
|
|
10
|
+
});
|
|
11
|
+
else obj[key] = value;
|
|
12
|
+
return obj;
|
|
13
|
+
}
|
|
14
|
+
const debug = getDebug('agent-tools:harmony');
|
|
15
|
+
function adaptHarmonyInitArgs(extracted) {
|
|
16
|
+
if (!extracted) return;
|
|
17
|
+
const initArgs = {
|
|
18
|
+
...'string' == typeof extracted.deviceId ? {
|
|
19
|
+
deviceId: extracted.deviceId
|
|
20
|
+
} : {},
|
|
21
|
+
...extractAgentBehaviorInitArgs(extracted) ?? {}
|
|
22
|
+
};
|
|
23
|
+
return Object.keys(initArgs).length > 0 ? initArgs : void 0;
|
|
24
|
+
}
|
|
25
|
+
class HarmonyMidsceneTools extends BaseMidsceneTools {
|
|
26
|
+
getCliReportSessionName() {
|
|
27
|
+
return 'midscene-harmony';
|
|
28
|
+
}
|
|
29
|
+
createTemporaryDevice() {
|
|
30
|
+
return new HarmonyDevice('temp-for-action-space', {});
|
|
31
|
+
}
|
|
32
|
+
async ensureAgent(initArgs) {
|
|
33
|
+
const deviceId = initArgs?.deviceId;
|
|
34
|
+
const nextSignature = getAgentInitArgsSignature(initArgs);
|
|
35
|
+
if (this.agent && shouldRebuildAgentForInitArgs(this.lastInitArgsSignature, nextSignature)) {
|
|
36
|
+
try {
|
|
37
|
+
await this.agent.destroy?.();
|
|
38
|
+
} catch (error) {
|
|
39
|
+
debug('Failed to destroy agent during cleanup:', error);
|
|
40
|
+
}
|
|
41
|
+
this.agent = void 0;
|
|
42
|
+
}
|
|
43
|
+
if (this.agent) return this.agent;
|
|
44
|
+
debug('Creating Harmony agent with deviceId:', deviceId || 'auto-detect');
|
|
45
|
+
const reportOptions = this.readCliReportAgentOptions();
|
|
46
|
+
const agent = await agentFromHdcDevice(deviceId, {
|
|
47
|
+
autoDismissKeyboard: false,
|
|
48
|
+
...extractAgentBehaviorInitArgs(initArgs) ?? {},
|
|
49
|
+
...reportOptions ?? {}
|
|
50
|
+
});
|
|
51
|
+
this.agent = agent;
|
|
52
|
+
this.lastInitArgsSignature = nextSignature;
|
|
53
|
+
return agent;
|
|
54
|
+
}
|
|
55
|
+
preparePlatformTools() {
|
|
56
|
+
return [
|
|
57
|
+
{
|
|
58
|
+
name: 'harmony_connect',
|
|
59
|
+
description: 'Connect to HarmonyOS device via HDC. If deviceId not provided, uses the first available device.',
|
|
60
|
+
schema: this.getAgentInitArgSchema(),
|
|
61
|
+
cli: this.getAgentInitArgCliMetadata(),
|
|
62
|
+
handler: async (args)=>{
|
|
63
|
+
const initArgs = this.extractAgentInitParam(args);
|
|
64
|
+
const deviceId = initArgs?.deviceId;
|
|
65
|
+
const reportSession = this.createNewCliReportSession(deviceId ?? 'auto');
|
|
66
|
+
this.commitCliReportSession(reportSession);
|
|
67
|
+
if (this.agent) {
|
|
68
|
+
try {
|
|
69
|
+
await this.agent.destroy?.();
|
|
70
|
+
} catch (error) {
|
|
71
|
+
debug('Failed to destroy agent during connect:', error);
|
|
72
|
+
}
|
|
73
|
+
this.agent = void 0;
|
|
74
|
+
this.lastInitArgsSignature = void 0;
|
|
75
|
+
}
|
|
76
|
+
const agent = await this.ensureAgent(initArgs);
|
|
77
|
+
const screenshot = await agent.page.screenshotBase64();
|
|
78
|
+
return {
|
|
79
|
+
content: [
|
|
80
|
+
{
|
|
81
|
+
type: 'text',
|
|
82
|
+
text: `Connected to HarmonyOS device${deviceId ? `: ${deviceId}` : ' (auto-detected)'}`
|
|
83
|
+
},
|
|
84
|
+
...this.buildScreenshotContent(screenshot)
|
|
85
|
+
],
|
|
86
|
+
isError: false
|
|
87
|
+
};
|
|
88
|
+
}
|
|
89
|
+
},
|
|
90
|
+
{
|
|
91
|
+
name: 'harmony_disconnect',
|
|
92
|
+
description: 'Disconnect from current HarmonyOS device and release HDC resources',
|
|
93
|
+
schema: {},
|
|
94
|
+
handler: this.createDisconnectHandler('HarmonyOS device')
|
|
95
|
+
}
|
|
96
|
+
];
|
|
97
|
+
}
|
|
98
|
+
constructor(...args){
|
|
99
|
+
super(...args), _define_property(this, "lastInitArgsSignature", void 0), _define_property(this, "initArgSpec", {
|
|
100
|
+
namespace: 'harmony',
|
|
101
|
+
shape: {
|
|
102
|
+
deviceId: z.string().optional().describe('HarmonyOS device ID (from hdc list targets)'),
|
|
103
|
+
...agentBehaviorInitArgShape
|
|
104
|
+
},
|
|
105
|
+
cli: {
|
|
106
|
+
preferBareKeys: true
|
|
107
|
+
},
|
|
108
|
+
adapt: adaptHarmonyInitArgs
|
|
109
|
+
});
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
export { HarmonyMidsceneTools };
|