tryharness 0.7.32 → 0.7.34

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.
@@ -0,0 +1,584 @@
1
+ import { createBoardFileCommands } from "./boardFileCommands.mjs";
2
+ import fs from "node:fs";
3
+ import os from "node:os";
4
+ import path from "node:path";
5
+ import { spawnSync } from "node:child_process";
6
+ import { createHash } from "node:crypto";
7
+ import {
8
+ documentText,
9
+ ensureDir,
10
+ isDocument,
11
+ mimeFor,
12
+ writeJsonAtomic,
13
+ } from "./files.mjs";
14
+ import { paths } from "./paths.mjs";
15
+ import { secretReason } from "./secrets.mjs";
16
+ import { ensureModels } from "./localmodels.mjs";
17
+ import { scrubDeep } from "./firewall.mjs";
18
+ import { imageKind } from "./ocr.mjs";
19
+ import { REDACTION_VERSION, describeMasked, redactImage } from "./redact.mjs";
20
+ import { nameOf } from "./members.mjs";
21
+ import { roomPage } from "./roomPage.mjs";
22
+
23
+ // A file one agent hands another, of any type. Its bytes stay in ~/.harness/files under their SHA-256; Harness carries
24
+ // them only sealed to the other person's computer, or readable to an agent on Harness's side (Muse, Grok Bot) when the
25
+ // agent that attached the file shared it with cloud agents. Each type is limited at what usually consumes it: an image
26
+ // at the Claude API's per-image limit, a PDF (by its %PDF- header, not its name) at the Claude API's PDF request limit,
27
+ // audio at OpenAI's transcription upload limit, anything else at Gmail's attachment limit.
28
+ const MB = 1024 * 1024;
29
+ const FILE_LIMITS = [
30
+ { kind: "images", bytes: 5 * MB, test: (mime) => mime.startsWith("image/") },
31
+ {
32
+ kind: "PDFs",
33
+ bytes: 32 * MB,
34
+ test: (mime, head) => mime === "application/pdf" && head === "%PDF-",
35
+ },
36
+ {
37
+ kind: "audio files",
38
+ bytes: 25 * MB,
39
+ test: (mime) => mime.startsWith("audio/"),
40
+ },
41
+ { kind: "other files", bytes: 25 * MB, test: () => true },
42
+ ];
43
+ export const MAX_FILE_BYTES = Math.max(
44
+ ...FILE_LIMITS.map((limit) => limit.bytes)
45
+ );
46
+ // One part of a file read through the sealed channel: 512 KiB is 683 KiB as base64, inside a sealed answer's 1 MB.
47
+ const FILE_PART_BYTES = 512 * 1024;
48
+ const fileLimit = (mime, bytes) =>
49
+ FILE_LIMITS.find((limit) =>
50
+ limit.test(mime, bytes.subarray(0, 5).toString("latin1"))
51
+ );
52
+
53
+ export function createBoardFiles({
54
+ store,
55
+ log,
56
+ localRoot,
57
+ localReady,
58
+ localEvent,
59
+ notifyBoard,
60
+ readFilesSoon,
61
+ roomOf,
62
+ visibleTo,
63
+ processing,
64
+ wakeFor,
65
+ }) {
66
+ const blobPath = (sha256) => path.join(paths.files, sha256);
67
+ const keepBlob = (bytes) => {
68
+ const sha256 = createHash("sha256").update(bytes).digest("hex");
69
+ ensureDir(paths.files);
70
+ if (!fs.existsSync(blobPath(sha256)))
71
+ fs.writeFileSync(blobPath(sha256), bytes, { mode: 0o600 });
72
+ return sha256;
73
+ };
74
+ // A caller through Harness sees a file only on a task it is part of; the person and this computer's agents see every file.
75
+ const visibleFile = (file, agent, hostedCaller) =>
76
+ !hostedCaller ||
77
+ agent === "user" ||
78
+ agent === "harness" ||
79
+ visibleTo(store.getTask(file.task_id), agent);
80
+ const fileName = (name) =>
81
+ String(name || "")
82
+ .replace(/[\\/\u0000-\u001f]/g, "")
83
+ .replace(/^\.+/, "")
84
+ .trim()
85
+ .slice(0, 200) || "file";
86
+ // For an agent here, the file under its own name (a hard link to the stored bytes), so its tools see what it is.
87
+ const namedPath = (file) => {
88
+ const named = path.join(paths.files, "named", file.id, file.name);
89
+ if (!fs.existsSync(named)) {
90
+ ensureDir(path.dirname(named));
91
+ try {
92
+ fs.linkSync(blobPath(file.sha256), named);
93
+ } catch {
94
+ fs.copyFileSync(blobPath(file.sha256), named);
95
+ }
96
+ }
97
+ return named;
98
+ };
99
+ const fileView = (file, hostedCaller) => ({
100
+ id: file.id,
101
+ task_id: file.task_id,
102
+ name: file.name,
103
+ mime: file.mime,
104
+ bytes: file.bytes,
105
+ author: file.author,
106
+ ...(hostedCaller
107
+ ? {}
108
+ : {
109
+ sha256: file.sha256,
110
+ shared_with_cloud: file.cloud,
111
+ arrived: file.present,
112
+ ...(file.present ? { path: namedPath(file) } : {}),
113
+ }),
114
+ });
115
+ const textLike = (mime) =>
116
+ /^text\/|^application\/(json|xml|yaml|x-yaml)$|^image\/svg\+xml$/.test(
117
+ mime
118
+ );
119
+ // The files of a thread (its goal and every task in it), or of a task on its own.
120
+ const placeFiles = (place) =>
121
+ [place, ...(place.kind === "goal" ? store.children(place.id) : [])].flatMap(
122
+ (task) => store.taskFiles(task.id)
123
+ );
124
+ // What Harness is told of a file: Harness's side reads only what was shared with it, and what it made itself.
125
+ const harnessShared = (file) => file.cloud || file.author === "harness";
126
+ const harnessFileView = (file) => ({
127
+ id: file.id,
128
+ name: file.name,
129
+ mime: file.mime,
130
+ bytes: file.bytes,
131
+ author: file.author,
132
+ shared: harnessShared(file),
133
+ });
134
+ // A thread's files as the buddy, PiP and phone show them, newest last, and the videos Harness is still rendering for it.
135
+ // Through Harness in the clear (an unpaired browser) no path; a file kept on this computer is named, never sent.
136
+ const renderingOf = (threadId) => {
137
+ try {
138
+ return JSON.parse(store.meta(`rendering:${threadId}`) || "[]");
139
+ } catch {
140
+ return [];
141
+ }
142
+ };
143
+ const threadFiles = (thread, hostedCaller = false) => ({
144
+ files: placeFiles(thread)
145
+ .filter((file) => file.present)
146
+ .map((file) => ({
147
+ id: file.id,
148
+ name: file.name,
149
+ mime: file.mime,
150
+ bytes: file.bytes,
151
+ author: file.author,
152
+ createdAt: file.created_at,
153
+ shared: file.cloud,
154
+ ...(hostedCaller ? {} : { path: namedPath(file) }),
155
+ })),
156
+ rendering: renderingOf(thread.id),
157
+ });
158
+ const tooBig = (bytes, limit = FILE_LIMITS.at(-1)) => ({
159
+ ok: false,
160
+ error: `the file is ${(bytes / MB).toFixed(1)} MB; ${limit.kind} on the board are up to ${limit.bytes / MB} MB (${FILE_LIMITS.map((each) => `${each.kind} ${each.bytes / MB} MB`).join(", ")})`,
161
+ });
162
+ const REDACT_MODELS = ["ocr", "credentials"];
163
+ let redactModels = null;
164
+ const redacting = new Map();
165
+ const redacted = (file) => {
166
+ const { ocr, firewall } = processing();
167
+ const base = path.join(
168
+ paths.files,
169
+ "redacted",
170
+ `${file.sha256}.v${REDACTION_VERSION}`
171
+ );
172
+ if (fs.existsSync(`${base}.json`)) {
173
+ const kept = JSON.parse(fs.readFileSync(`${base}.json`, "utf8"));
174
+ return Promise.resolve({
175
+ ...kept,
176
+ bytes: kept.refused
177
+ ? null
178
+ : fs.readFileSync(
179
+ kept.covered ? `${base}.png` : blobPath(file.sha256)
180
+ ),
181
+ cached: true,
182
+ });
183
+ }
184
+ if (!redacting.has(file.sha256)) {
185
+ const picture = checkable(file);
186
+ redacting.set(
187
+ file.sha256,
188
+ redactImage(picture, { ocr, firewall, lane: "handoff" })
189
+ .then((out) => {
190
+ ensureDir(path.dirname(base));
191
+ // A picture checked as a PNG of it leaves as that PNG, what was checked.
192
+ const covered =
193
+ Boolean(out.masked?.length) || picture.converted === true;
194
+ // The .json is written last and whole: present, it vouches for the .png beside it.
195
+ if (covered)
196
+ fs.writeFileSync(`${base}.png`, out.bytes, { mode: 0o600 });
197
+ const kept = out.refused
198
+ ? { refused: out.refused }
199
+ : { covered, mime: out.mime, masked: out.masked, ms: out.ms };
200
+ writeJsonAtomic(`${base}.json`, kept);
201
+ return { ...kept, bytes: out.bytes ?? null, cached: false };
202
+ })
203
+ .finally(() => redacting.delete(file.sha256))
204
+ );
205
+ }
206
+ return redacting.get(file.sha256);
207
+ };
208
+ // The check reads PNG and JPEG: any other picture (WebP, GIF, HEIC) is checked as a PNG of it, made by the Mac's own
209
+ // converter (sips). An animated one is its first frame.
210
+ const checkable = (file) => {
211
+ const bytes = fs.readFileSync(blobPath(file.sha256));
212
+ if (imageKind(bytes) || process.platform !== "darwin")
213
+ return { bytes, mime: file.mime };
214
+ const dir = fs.mkdtempSync(path.join(os.tmpdir(), "harness-picture-"));
215
+ try {
216
+ const made = spawnSync(
217
+ "sips",
218
+ [
219
+ "-s",
220
+ "format",
221
+ "png",
222
+ blobPath(file.sha256),
223
+ "--out",
224
+ path.join(dir, "picture.png"),
225
+ ],
226
+ { encoding: "utf8" }
227
+ );
228
+ return made.status === 0
229
+ ? {
230
+ bytes: fs.readFileSync(path.join(dir, "picture.png")),
231
+ mime: "image/png",
232
+ converted: true,
233
+ }
234
+ : { bytes, mime: file.mime };
235
+ } finally {
236
+ fs.rmSync(dir, { recursive: true, force: true });
237
+ }
238
+ };
239
+ /** A plain board.file.get answer for an image, with the covered copy in place of the original. */
240
+ const coveredImage = async (answer, file, agent) => {
241
+ if (!localReady(REDACT_MODELS)) {
242
+ redactModels ||= ensureModels({
243
+ root: localRoot,
244
+ ids: REDACT_MODELS,
245
+ log,
246
+ })
247
+ .then(
248
+ () => log("redaction: the OCR and credential models are ready"),
249
+ (error) =>
250
+ log(`redaction: the models did not download (${error.message})`)
251
+ )
252
+ .finally(() => {
253
+ redactModels = null;
254
+ });
255
+ return {
256
+ ok: false,
257
+ code: "held",
258
+ error:
259
+ "This image stays on the person's computer until Harness's local check for keys and personal details in images is ready. It is downloading now; ask again in a few minutes.",
260
+ };
261
+ }
262
+ const out = await redacted(file);
263
+ if (out.refused)
264
+ return {
265
+ ok: false,
266
+ code: "held",
267
+ error: `This image stays on the person's computer: ${out.refused}.`,
268
+ };
269
+ const reader =
270
+ agent === "user"
271
+ ? "it went through Harness to your window"
272
+ : `${nameOf(agent)} read it`;
273
+ const found = describeMasked(out.masked);
274
+ if (found.count) {
275
+ // One note per file and reader, however often it is read.
276
+ const id = createHash("sha256")
277
+ .update(`redacted:${file.id}:${agent}`)
278
+ .digest("hex")
279
+ .replace(/^(.{8})(.{4})(.{4})(.{4})(.{12}).*$/, "$1-$2-$3-$4-$5");
280
+ if (!store.getContribution(id)) {
281
+ store.addContribution({
282
+ id,
283
+ taskId: file.task_id,
284
+ kind: "note",
285
+ author: "harness",
286
+ text: `Hid ${found.count} thing${found.count === 1 ? "" : "s"} in ${file.name} before ${reader}: ${found.text}.`,
287
+ source: `file:${file.id}`,
288
+ });
289
+ notifyBoard(store.getTask(file.task_id));
290
+ }
291
+ }
292
+ localEvent(
293
+ "redact",
294
+ found.count
295
+ ? `hid ${found.count} thing${found.count === 1 ? "" : "s"} in an image before ${reader}`
296
+ : `checked an image before ${reader}: nothing to hide`,
297
+ out.cached ? null : out.ms
298
+ );
299
+ return {
300
+ ...answer,
301
+ file: {
302
+ ...answer.file,
303
+ mime: out.covered ? out.mime : answer.file.mime,
304
+ bytes: out.bytes.length,
305
+ },
306
+ data: out.bytes.toString("base64"),
307
+ };
308
+ };
309
+ // Harness's files on a task given to it, asked by Harness's server for the run or window working it
310
+ // (src/server/swarm/threadFiles.ts): it lists and reads what its thread shared with agents on Harness's side, under the
311
+ // checks any agent reading through Harness gets, and adds what it made there. Allowed with a browser paired too: what
312
+ // Harness adds it made on its own servers, as with its answers to the tasks given to it.
313
+ const harnessFile = async (input) => {
314
+ const { scrubber } = processing();
315
+ const task = store.getTask(String(input.taskId || ""));
316
+ if (!task || task.target_agent !== "harness")
317
+ return { ok: false, error: "not a task given to Harness" };
318
+ const place = roomOf(task) ?? task;
319
+ // The thread's posts a page at a time, as every agent reads them (roomPage.mjs): its newest, the ones before a post
320
+ // going back, or the ones after one Harness has seen, so it reads the thread again before it answers (October 15:
321
+ // answers built on the snapshot its task started with restated what had changed since). Keys are swapped out, as in
322
+ // its task.
323
+ if (input.op === "posts") {
324
+ const page = roomPage(store, place.id, {
325
+ since: Math.max(0, Math.floor(Number(input.since) || 0)),
326
+ before: Math.max(0, Math.floor(Number(input.before) || 0)),
327
+ });
328
+ const posts = page.posts.map((post) => ({
329
+ seq: post.seq,
330
+ author: post.author,
331
+ kind: post.kind,
332
+ text: post.text,
333
+ at: post.created_at,
334
+ }));
335
+ return {
336
+ ok: true,
337
+ posts: scrubber ? await scrubDeep(scrubber, posts, new Map()) : posts,
338
+ earlierBefore: page.earlierBefore,
339
+ laterAfter: page.laterAfter,
340
+ };
341
+ }
342
+ const files = placeFiles(place);
343
+ if (input.op === "list")
344
+ return {
345
+ ok: true,
346
+ files: files.filter((file) => file.present).map(harnessFileView),
347
+ };
348
+ if (input.op === "get") {
349
+ const file = files.find((each) => each.id === String(input.fileId || ""));
350
+ if (!file)
351
+ return { ok: false, error: "no file with that id in this thread" };
352
+ if (!harnessShared(file))
353
+ return {
354
+ ok: false,
355
+ code: "sealed",
356
+ error: `${file.name} is kept on the person's computer, so agents on Harness's side cannot read it: only the person can share it (Share with Harness, on the file)`,
357
+ };
358
+ if (!file.present)
359
+ return {
360
+ ok: false,
361
+ error: "this file is still on its way from the other computer",
362
+ };
363
+ // A document goes as its words, checked as a text file is.
364
+ const words = isDocument(file.mime)
365
+ ? documentText(namedPath(file), file.mime)
366
+ : null;
367
+ if (words !== null) {
368
+ const flag = file.author !== "harness" && secretReason(words);
369
+ return flag
370
+ ? {
371
+ ok: false,
372
+ error: `held on the person's computer: this file looked like it holds ${flag}`,
373
+ }
374
+ : { ok: true, file: harnessFileView(file), text: words };
375
+ }
376
+ const bytes = fs.readFileSync(blobPath(file.sha256));
377
+ const answer = {
378
+ ok: true,
379
+ file: harnessFileView(file),
380
+ data: bytes.toString("base64"),
381
+ };
382
+ if (file.author === "harness") return partOf(answer, input);
383
+ const flag = textLike(file.mime) && secretReason(bytes.toString("utf8"));
384
+ if (flag)
385
+ return {
386
+ ok: false,
387
+ error: `held on the person's computer: this file looked like it holds ${flag}`,
388
+ };
389
+ return (file.mime.startsWith("image/") && !textLike(file.mime)) ||
390
+ imageKind(bytes.subarray(0, 12))
391
+ ? coveredImage(answer, file, "harness").then((covered) =>
392
+ partOf(covered, input)
393
+ )
394
+ : partOf(answer, input);
395
+ }
396
+ // A video Harness is rendering for the task: shown in the thread until it lands or fails.
397
+ const rendering = renderingOf(place.id);
398
+ const setRendering = (next) => {
399
+ store.meta(`rendering:${place.id}`, JSON.stringify(next));
400
+ notifyBoard(store.getTask(place.id));
401
+ };
402
+ const jobId = String(input.jobId || "").slice(0, 64);
403
+ if (input.op === "rendering") {
404
+ if (!jobId) return { ok: false, error: "a rendering needs its job" };
405
+ if (!rendering.some((each) => each.jobId === jobId))
406
+ setRendering([
407
+ ...rendering,
408
+ {
409
+ jobId,
410
+ taskId: task.id,
411
+ name: fileName(input.name),
412
+ expect: input.expect === "shortly" ? "shortly" : "in a few minutes",
413
+ startedAt: new Date().toISOString(),
414
+ },
415
+ ]);
416
+ return { ok: true };
417
+ }
418
+ if (input.op === "rendering_failed") {
419
+ const job = rendering.find((each) => each.jobId === jobId);
420
+ if (!job) return { ok: true };
421
+ setRendering(rendering.filter((each) => each.jobId !== jobId));
422
+ if (place.kind === "goal" && place.status === "open") {
423
+ const post = store.roomPost({
424
+ goalId: place.id,
425
+ author: "harness",
426
+ kind: "result",
427
+ text: `${job.name} could not be made: ${String(input.reason || "the render failed").slice(0, 500)}`,
428
+ mentions: [task.origin_agent].filter((agent) =>
429
+ place.goal.team.includes(agent)
430
+ ),
431
+ });
432
+ wakeFor(place.id, post, "harness");
433
+ }
434
+ return { ok: true };
435
+ }
436
+ if (input.op !== "add") return { ok: false, error: "unknown file request" };
437
+ const bytes = Buffer.from(String(input.data || ""), "base64");
438
+ if (!bytes.length) return { ok: false, error: "the file is empty" };
439
+ // A finished render keeps the name its rendering was given (the shot it is), and no two of Harness's files in a
440
+ // thread share a name (October 15: four takes all named set-a-tiny-character-on-a.mp4, told apart by guesswork).
441
+ const named = fileName(
442
+ (jobId && rendering.find((each) => each.jobId === jobId)?.name) ||
443
+ input.name
444
+ );
445
+ const taken = new Set(
446
+ files.filter((each) => each.author === "harness").map((each) => each.name)
447
+ );
448
+ const dot = named.lastIndexOf(".");
449
+ const [stem, extension] =
450
+ dot > 0 ? [named.slice(0, dot), named.slice(dot)] : [named, ""];
451
+ let name = named;
452
+ for (let n = 2; taken.has(name); n++) name = `${stem}-${n}${extension}`;
453
+ const mime = /^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(String(input.mime || ""))
454
+ ? String(input.mime).toLowerCase()
455
+ : mimeFor(name);
456
+ const limit = fileLimit(mime, bytes);
457
+ if (bytes.length > limit.bytes) return tooBig(bytes.length, limit);
458
+ const sha256 = keepBlob(bytes);
459
+ // The same bytes Harness made before in this thread are the same file; a delivery sent again (the server did not hear
460
+ // back) for the same task changes nothing.
461
+ let file = files.find(
462
+ (each) => each.author === "harness" && each.sha256 === sha256
463
+ );
464
+ if (file && harnessFilesOf(task.id).includes(file.id))
465
+ return { ok: true, file: harnessFileView(file) };
466
+ if (!file) {
467
+ file = store.addFile({
468
+ taskId: place.id,
469
+ name,
470
+ mime,
471
+ bytes: bytes.length,
472
+ sha256,
473
+ author: "harness",
474
+ cloud: true,
475
+ });
476
+ store.addContribution({
477
+ taskId: place.id,
478
+ kind: "file",
479
+ author: "harness",
480
+ text: `harness attached ${fileLine(file)}`,
481
+ source: `file:${file.id}`,
482
+ });
483
+ }
484
+ store.meta(
485
+ `harness-files:${task.id}`,
486
+ JSON.stringify([...harnessFilesOf(task.id), file.id])
487
+ );
488
+ if (jobId && rendering.some((each) => each.jobId === jobId))
489
+ store.meta(
490
+ `rendering:${place.id}`,
491
+ JSON.stringify(rendering.filter((each) => each.jobId !== jobId))
492
+ );
493
+ // Made after Harness answered (a video renders for minutes): said in the thread, waking whoever asked. Asked by
494
+ // Harness itself (the coordinator handing work on in its name), there is no one else to wake and the file's own post
495
+ // shows it (October 16, the content factory: five "Made for Harness" posts, each a copy of the file posted above it).
496
+ if (
497
+ ["done", "failed"].includes(task.status) &&
498
+ place.kind === "goal" &&
499
+ place.status === "open" &&
500
+ task.origin_agent !== "harness"
501
+ ) {
502
+ const forWhom =
503
+ task.origin_agent === "user" ? "you" : nameOf(task.origin_agent);
504
+ const post = store.roomPost({
505
+ goalId: place.id,
506
+ author: "harness",
507
+ kind: "result",
508
+ text: `Made for ${forWhom}: ${file.name}\n\nFiles: ${fileLine(file)}`.slice(
509
+ 0,
510
+ 20_000
511
+ ),
512
+ mentions: [task.origin_agent].filter((agent) =>
513
+ place.goal.team.includes(agent)
514
+ ),
515
+ });
516
+ wakeFor(place.id, post, "harness");
517
+ }
518
+ notifyBoard(store.getTask(place.id));
519
+ return { ok: true, file: harnessFileView(file) };
520
+ };
521
+ // One part of what goes to Harness (after its checks), when Harness's server reads a file in parts: one call on the
522
+ // bridge carries no more than a sealed part does.
523
+ const partOf = (answer, input) => {
524
+ if (input.offset === undefined || !answer?.ok || answer.data === undefined)
525
+ return answer;
526
+ const bytes = Buffer.from(answer.data, "base64"),
527
+ offset = Number(input.offset);
528
+ if (!Number.isSafeInteger(offset) || offset < 0 || offset >= bytes.length)
529
+ return { ok: false, error: "offset must be a byte within the file" };
530
+ return {
531
+ ...answer,
532
+ file: { ...answer.file, bytes: bytes.length },
533
+ offset,
534
+ data: bytes.subarray(offset, offset + FILE_PART_BYTES).toString("base64"),
535
+ };
536
+ };
537
+ const harnessFilesOf = (taskId) => {
538
+ try {
539
+ return JSON.parse(store.meta(`harness-files:${taskId}`) || "[]");
540
+ } catch {
541
+ return [];
542
+ }
543
+ };
544
+ const fileLine = (file) =>
545
+ `${file.name} (${file.mime}, ${(file.bytes / MB).toFixed(1)} MB), file ${file.id}; read it with get_file`;
546
+
547
+ const command = createBoardFileCommands({
548
+ FILE_LIMITS,
549
+ FILE_PART_BYTES,
550
+ MAX_FILE_BYTES,
551
+ MB,
552
+ blobPath,
553
+ fileLimit,
554
+ fileLine,
555
+ fileName,
556
+ fileView,
557
+ keepBlob,
558
+ namedPath,
559
+ notifyBoard,
560
+ readFilesSoon,
561
+ roomOf,
562
+ store,
563
+ textLike,
564
+ tooBig,
565
+ visibleFile,
566
+ });
567
+ return {
568
+ command,
569
+ blobPath,
570
+ keepBlob,
571
+ visibleFile,
572
+ fileName,
573
+ namedPath,
574
+ fileView,
575
+ textLike,
576
+ placeFiles,
577
+ harnessFileView,
578
+ threadFiles,
579
+ coveredImage,
580
+ harnessFile,
581
+ harnessFilesOf,
582
+ fileLine,
583
+ };
584
+ }