@orkestrel/scaffold 0.0.108 → 0.0.109

package/dist/agents/skills/orkestrel-dispatch/scripts/patch.js

@@ -0,0 +1,323 @@
+// Apply an edit file of exact old-to-new replacements. Run from the checkout root:
+//   node .agents/skills/orkestrel-dispatch/scripts/patch.ts EDITS.md (--plan | --apply) [--skip N ...]
+// An edit file holds blocks of this shape, in the order they apply:
+//   ### path/relative/to/the/working/directory
+//   reason: one line saying why
+//   old:
+//   ```ts
+//   the exact text to replace
+//   ```
+//   new:
+//   ```ts
+//   the replacement text
+//   ```
+// A fence opens with three or more backticks and closes with the same count, so a block can carry a
+// shorter fence. Prose outside the blocks is ignored, but a stray `###`, `reason:`, `old:`, or `new:`
+// line that opens no complete block is refused. Every `old` text must occur exactly once in its file
+// after the earlier edits to that file, however the blocks spell its path (`src/a.ts` and `./src/a.ts`
+// name one file), and nothing is written unless every selected edit resolves.
+// `--plan` prints each edit's resolution and writes nothing; `--apply` writes the files after every
+// edit resolved. `--skip N` leaves out edit number N, as the plan numbers them, and repeats. The
+// script refuses a flag it does not read, the `--flag=value` form included.
+// Exit 0 when every selected edit resolved, 1 when one did not, 64 on usage.
+import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+/** Lists the flags that each select one operation. */
+export const MODE_FLAGS = ['--plan', '--apply'];
+/** Lists the flags that take a value. */
+export const VALUE_FLAGS = ['--skip'];
+/** Lists every flag the script reads, value flags and switches alike. */
+export const FLAGS = [...MODE_FLAGS, ...VALUE_FLAGS];
+/** Holds the usage line printed when a call names no edit file or no mode, or two. */
+export const USAGE = 'usage: patch.ts EDITS.md (--plan | --apply) [--skip N ...]; name one mode; --skip repeats';
+/** Matches one edit block with its path, reason, and fenced old and new texts. */
+export const EDIT_BLOCK = /^### (.+?)[ \t]*\n+reason:[ \t]*(.*?)[ \t]*\n+old:\n+(`{3,})[^\n`]*\n([\s\S]*?)\n\3[ \t]*\n+new:\n+(`{3,})[^\n`]*\n([\s\S]*?)\n?\5[ \t]*$/gmu;
+/** Matches a line that belongs to an edit block and so must not remain outside one. */
+export const STRAY_LINE = /^(?:### |reason:|old:|new:)/u;
+/**
+ * Names the value flags a caller gave with no value, at any occurrence.
+ *
+ * @param argv - The arguments after the script path.
+ * @param names - The flags that take a value.
+ * @returns Each named flag that appears last or is followed by another flag, in argument order.
+ */
+export function readMissingFlags(argv, names) {
+    return names.filter((name) => argv.some((argument, index) => argument === name && isMissingValue(argv, index)));
+}
+/**
+ * Checks whether the argument after a flag is absent or is another flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param index - The position of the flag.
+ * @returns True when no value follows the flag; false otherwise.
+ */
+export function isMissingValue(argv, index) {
+    const value = argv[index + 1];
+    return value === undefined || value.startsWith('--');
+}
+/**
+ * Names the flags a caller gave that the script does not read.
+ *
+ * @remarks
+ * A `--flag=value` argument is unknown, because the script reads no such form. A bare `--` ends the
+ * scan.
+ *
+ * @param argv - The arguments after the script path.
+ * @param flags - Every flag the script reads, value flags and switches alike.
+ * @returns Each argument that opens with `--` and is not a read flag, in argument order.
+ */
+export function readUnknownFlags(argv, flags) {
+    const end = argv.indexOf('--');
+    return (end === -1 ? argv : argv.slice(0, end)).filter((argument) => argument.startsWith('--') && !flags.includes(argument));
+}
+/**
+ * Reads every value that follows a repeatable flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param name - The flag, such as `--skip`.
+ * @returns The values in order, empty when the flag never appears.
+ */
+export function readOptions(argv, name) {
+    return argv.flatMap((argument, index) => {
+        const value = argv[index + 1];
+        return argument === name && value !== undefined && !value.startsWith('--') ? [value] : [];
+    });
+}
+/**
+ * Reads the arguments that are neither a flag nor the value of a value flag.
+ *
+ * @param argv - The arguments after the script path.
+ * @param valueFlags - The flags that take a value.
+ * @returns The positional arguments in order.
+ */
+export function readPositionals(argv, valueFlags) {
+    return argv.filter((argument, index) => !argument.startsWith('--') && !valueFlags.includes(argv[index - 1] ?? ''));
+}
+/**
+ * Quotes an untrusted text for a diagnostic, JSON-encoded and cut to a bounded length.
+ *
+ * @param text - The text to quote.
+ * @returns The JSON string literal of the text, ending in an ellipsis inside the quotes when cut.
+ */
+export function quote(text) {
+    return JSON.stringify(text.length > 80 ? `${text.slice(0, 80)}…` : text);
+}
+/**
+ * Reads the edit blocks of an edit file in order.
+ *
+ * @param text - The edit file's text; a carriage return before a line break is ignored.
+ * @returns Each complete block as an edit numbered from 1.
+ */
+export function parseEdits(text) {
+    return [...text.replace(/\r\n/gu, '\n').matchAll(EDIT_BLOCK)].map((match, index) => ({
+        number: index + 1,
+        path: match[1] ?? '',
+        reason: match[2] ?? '',
+        before: match[4] ?? '',
+        after: match[6] ?? '',
+    }));
+}
+/**
+ * Finds the lines of an edit file that open or continue a block no complete block holds.
+ *
+ * @param text - The edit file's text.
+ * @returns Each stray `###`, `reason:`, `old:`, or `new:` line, in order.
+ */
+export function readStrays(text) {
+    return text
+        .replace(/\r\n/gu, '\n')
+        .replace(EDIT_BLOCK, '')
+        .split(/\r\n|\n/u)
+        .filter((line) => STRAY_LINE.test(line));
+}
+/**
+ * Counts how many places a text occurs in another, overlapping places included.
+ *
+ * @param text - The text to search.
+ * @param part - The text to find; an empty text occurs nowhere.
+ * @returns The number of start positions at which `part` occurs.
+ */
+export function countOccurrences(text, part) {
+    if (part === '')
+        return 0;
+    const escaped = part.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    return [...text.matchAll(new RegExp(`(?=${escaped})`, 'gu'))].length;
+}
+/**
+ * Applies a file's edits in order, each against the text the earlier edits left.
+ *
+ * @param text - The file's text before any edit.
+ * @param edits - The file's edits in file order.
+ * @returns The text after the edits that resolved and one outcome per edit; an edit whose `old` text
+ * does not occur exactly once changes nothing and carries its problem.
+ */
+export function applyEdits(text, edits) {
+    return edits.reduce((state, edit) => {
+        const count = countOccurrences(state.text, edit.before);
+        const problem = count === 1 ? undefined : `old text occurs ${String(count)} times`;
+        return {
+            text: problem === undefined ? state.text.replace(edit.before, () => edit.after) : state.text,
+            outcomes: [...state.outcomes, describeOutcome(edit, problem)],
+        };
+    }, { text, outcomes: [] });
+}
+/**
+ * Describes what happened to one edit.
+ *
+ * @param edit - The edit.
+ * @param problem - The problem that stopped it, or undefined when it resolved.
+ * @returns The edit's number, path, and reason with the problem.
+ */
+export function describeOutcome(edit, problem) {
+    return { number: edit.number, path: edit.path, reason: edit.reason, problem };
+}
+/**
+ * Checks whether a path sits strictly inside a directory.
+ *
+ * @param root - The directory.
+ * @param target - The path to check.
+ * @returns True when `target` is below `root`; false for `root` itself and for any path outside.
+ */
+export function isInside(root, target) {
+    const path = relative(root, target);
+    return path !== '' && path !== '..' && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+/**
+ * Reads the numbers a caller asked to skip.
+ *
+ * @param values - The `--skip` values.
+ * @param count - How many edits the file holds.
+ * @returns Each value that is not a whole number from 1 to `count`, in order.
+ */
+export function readInvalidSkips(values, count) {
+    return values.filter((value) => !/^[1-9]\d*$/u.test(value) || Number(value) > count);
+}
+/**
+ * Resolves every selected edit against the files under a root, writing nothing.
+ *
+ * @param root - The working directory the edit paths resolve against.
+ * @param edits - The selected edits in file order.
+ * @returns One outcome per edit in file order, and the text of each file whose edits all resolved.
+ */
+export function resolveEdits(root, edits) {
+    const keyed = edits.map((edit) => {
+        const target = resolve(root, edit.path);
+        return { edit, target, key: readFileKey(target) };
+    });
+    const results = [...new Set(keyed.map((item) => item.key))].map((key) => {
+        const group = keyed.filter((item) => item.key === key);
+        const own = group.map((item) => item.edit);
+        const path = own[0]?.path ?? '';
+        const target = group[0]?.target ?? '';
+        const problem = group
+            .map((item) => readTargetProblem(root, item.target))
+            .find((candidate) => candidate !== undefined);
+        if (problem !== undefined) {
+            return { path, text: undefined, outcomes: own.map((edit) => describeOutcome(edit, problem)) };
+        }
+        const resolution = applyEdits(readFileSync(target, 'utf8'), own);
+        const failed = resolution.outcomes.some((outcome) => outcome.problem !== undefined);
+        return { path, text: failed ? undefined : resolution.text, outcomes: resolution.outcomes };
+    });
+    return {
+        outcomes: results.flatMap((result) => result.outcomes).sort((a, b) => a.number - b.number),
+        files: results.flatMap((result) => result.text === undefined ? [] : [{ path: result.path, text: result.text }]),
+    };
+}
+/**
+ * Names the file an edit target stands for, so every spelling of one file shares one key.
+ *
+ * @remarks
+ * The host's own path resolution folds case where the host folds it, so `./src/a.ts`, `src/a.ts`, and
+ * on a case-folding host `SRC/A.ts` name one key when the file exists.
+ *
+ * @param target - The resolved target path.
+ * @returns The file's canonical path when it exists, and the resolved path otherwise.
+ */
+export function readFileKey(target) {
+    return existsSync(target) ? realpathSync.native(target) : target;
+}
+/**
+ * Names why an edit target cannot be edited.
+ *
+ * @param root - The working directory the edit paths resolve against.
+ * @param target - The resolved target path.
+ * @returns The problem, or undefined when the target is a file inside the root.
+ */
+export function readTargetProblem(root, target) {
+    if (!isInside(root, target))
+        return 'path leaves the working directory';
+    if (!existsSync(target) || !statSync(target).isFile())
+        return 'no such file';
+    return undefined;
+}
+/**
+ * Runs the script on its arguments.
+ *
+ * @param argv - The arguments after the script path.
+ * @returns The exit code: 0 when every selected edit resolved, 1 when one did not, 64 on usage.
+ */
+export function main(argv) {
+    const unknown = readUnknownFlags(argv, FLAGS);
+    if (unknown.length > 0) {
+        console.error(`patch: ${unknown.join(', ')} is not a flag this script reads; ${USAGE}`);
+        return 64;
+    }
+    const missing = readMissingFlags(argv, VALUE_FLAGS);
+    if (missing.length > 0) {
+        console.error(`patch: ${missing.join(', ')} given with no value`);
+        return 64;
+    }
+    const modes = MODE_FLAGS.filter((flag) => argv.includes(flag));
+    const sources = readPositionals(argv, VALUE_FLAGS);
+    const source = sources[0];
+    if (modes.length !== 1 || sources.length !== 1 || source === undefined) {
+        console.error(USAGE);
+        return 64;
+    }
+    if (!existsSync(source) || !statSync(source).isFile()) {
+        console.error(`patch: ${quote(source)} is not a readable edit file; ${USAGE}`);
+        return 64;
+    }
+    const text = readFileSync(source, 'utf8');
+    const edits = parseEdits(text);
+    const strays = readStrays(text);
+    if (edits.length === 0 || strays.length > 0) {
+        console.error(`patch: ${quote(source)} ${edits.length === 0 ? 'holds no complete edit block' : `has a line that opens no complete block: ${strays.map(quote).join(', ')}`}; a block is a "### path" line, a "reason:" line, and fenced "old:" and "new:" texts`);
+        return 64;
+    }
+    const skips = readOptions(argv, '--skip');
+    const invalid = readInvalidSkips(skips, edits.length);
+    if (invalid.length > 0) {
+        console.error(`patch: --skip ${invalid.map(quote).join(', ')} names no edit; the file holds edits 1 to ${String(edits.length)}`);
+        return 64;
+    }
+    const skipped = new Set(skips.map(Number));
+    const selected = edits.filter((edit) => !skipped.has(edit.number));
+    const root = process.cwd();
+    const resolution = resolveEdits(root, selected);
+    for (const edit of edits) {
+        const outcome = resolution.outcomes.find((candidate) => candidate.number === edit.number);
+        if (outcome === undefined)
+            console.log(`#${String(edit.number)} skipped ${edit.path}`);
+        else if (outcome.problem === undefined) {
+            console.log(`#${String(edit.number)} ok ${edit.path} — ${edit.reason}`);
+        }
+        else
+            console.log(`#${String(edit.number)} FAIL ${edit.path}: ${outcome.problem}`);
+    }
+    if (resolution.outcomes.some((outcome) => outcome.problem !== undefined)) {
+        console.log('nothing written');
+        return 1;
+    }
+    const apply = argv.includes('--apply');
+    if (apply) {
+        for (const file of resolution.files)
+            writeFileSync(resolve(root, file.path), file.text);
+    }
+    console.log(`${apply ? 'applied' : 'planned'} edits to ${String(resolution.files.length)} file(s)`);
+    return 0;
+}
+if (process.argv[1] !== undefined && realpathSync(process.argv[1]) === import.meta.filename) {
+    process.exitCode = main(process.argv.slice(2));
+}

package/dist/agents/skills/orkestrel-dispatch/scripts/result.js

@@ -9,30 +9,134 @@
 // launch.ts wrote (`exit`, `capped`, `durationMs`) and the journal's `bytes`, `ageMs`, and last
 // event, which is the liveness reading for a run still going. The answer is written to --out when
 // given, and a journal with no session or answer exits 3 so a driver cannot pass off an empty lane.
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+// Name one mode per run; the script refuses a flag it does not read, the `--flag=value` form
+// included. Exit 0 when the lane answered, 3 when it carries no session or answer, 64 on usage.
+import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { readMissingFlags, readNumber, readOption, readString } from "./helpers.js";
-function readEvents(path) {
+/** Lists the flags that each select one journal reader. */
+export const MODE_FLAGS = ['--cursor', '--claude', '--codex'];
+/** Lists the flags that take a value. */
+export const VALUE_FLAGS = [...MODE_FLAGS, '--out'];
+/** Lists every flag the script reads, value flags and switches alike. */
+export const FLAGS = VALUE_FLAGS;
+/** Holds the usage line printed when a call names no journal or two modes. */
+export const USAGE = 'usage: result.ts (--cursor JOURNAL | --claude JOURNAL | --codex JOURNAL) [--out PATH]; name one mode';
+/**
+ * Reads the value that follows a flag.
+ *
+ * @remarks
+ * The first occurrence of a flag wins, a following value that opens with `--` is a missing value,
+ * and the `--flag=value` form is not read.
+ *
+ * @param argv - The arguments after the script path.
+ * @param name - The flag, such as `--out`.
+ * @returns The value after the flag, or undefined when the flag is absent, last, or followed by
+ * another flag.
+ */
+export function readOption(argv, name) {
+    const index = argv.indexOf(name);
+    const value = index === -1 ? undefined : argv[index + 1];
+    return value === undefined || value.startsWith('--') ? undefined : value;
+}
+/**
+ * Names the value flags a caller gave with no value.
+ *
+ * @param argv - The arguments after the script path.
+ * @param names - The flags that take a value.
+ * @returns Each named flag that appears last or is followed by another flag, in argument order.
+ */
+export function readMissingFlags(argv, names) {
+    return names.filter((name) => argv.includes(name) && readOption(argv, name) === undefined);
+}
+/**
+ * Names the flags a caller gave that the script does not read.
+ *
+ * @remarks
+ * A `--flag=value` argument is unknown, because the script reads no such form. A bare `--` ends the
+ * scan.
+ *
+ * @param argv - The arguments after the script path.
+ * @param flags - Every flag the script reads, value flags and switches alike.
+ * @returns Each argument that opens with `--` and is not a read flag, in argument order.
+ */
+export function readUnknownFlags(argv, flags) {
+    const end = argv.indexOf('--');
+    return (end === -1 ? argv : argv.slice(0, end)).filter((argument) => argument.startsWith('--') && !flags.includes(argument));
+}
+/**
+ * Reads the last non-empty line of a text as a JSON object.
+ *
+ * @param text - Text whose last line is JSON, such as one journal line.
+ * @returns The parsed object, or undefined when the last line is not a JSON object.
+ */
+export function parseJsonLine(text) {
+    const line = text
+        .split(/\r\n|\n/)
+        .filter((candidate) => candidate.trim() !== '')
+        .at(-1);
+    if (line === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return Object.fromEntries(Object.entries(parsed));
+        }
+    }
+    catch { }
+    return undefined;
+}
+/**
+ * Reads a string member of a record.
+ *
+ * @param record - The record, or undefined.
+ * @param key - The member name.
+ * @returns The string, or undefined when the member is absent or not a string.
+ */
+export function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * Reads a finite number member of a record.
+ *
+ * @param record - The record, or undefined.
+ * @param key - The member name.
+ * @returns The number, or undefined when the member is absent, not a number, or not finite.
+ */
+export function readNumber(record, key) {
+    const value = record?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+/**
+ * Reads every JSON object line of a journal.
+ *
+ * @param path - The journal file.
+ * @returns Each line that parses as a JSON object, in order; a blank or malformed line is skipped.
+ */
+export function readEvents(path) {
     return readFileSync(path, 'utf8')
         .split(/\r\n|\n/)
         .flatMap((line) => {
-        if (line.trim() === '')
-            return [];
-        try {
-            const parsed = JSON.parse(line);
-            return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
-                ? [Object.fromEntries(Object.entries(parsed))]
-                : [];
-        }
-        catch {
-            return [];
-        }
+        const event = parseJsonLine(line);
+        return event === undefined ? [] : [event];
     });
 }
-function readAnswer(text) {
+/**
+ * Reads an answer text as present only when it carries something besides whitespace.
+ *
+ * @param text - The answer text, or undefined.
+ * @returns The text unchanged, or undefined when it is absent or blank.
+ */
+export function readAnswer(text) {
     return text === undefined || text.trim() === '' ? undefined : text;
 }
-function readStream(events) {
+/**
+ * Reads a Cursor or Claude stream journal's events.
+ *
+ * @param events - The journal's events.
+ * @returns The session from the `init` event and the answer and duration from the `result` event.
+ */
+export function readStream(events) {
     const init = events.find((event) => event.type === 'system' && event.subtype === 'init');
     const result = events.find((event) => event.type === 'result');
     return {
@@ -41,7 +145,14 @@ function readStream(events) {
         durationMs: result === undefined ? undefined : readNumber(result, 'duration_ms'),
     };
 }
-function readCodex(path, events) {
+/**
+ * Reads a Codex journal's events and its sibling last-message file.
+ *
+ * @param path - The journal path; the answer sits beside it in `<name>-last.md`.
+ * @param events - The journal's events.
+ * @returns The thread id from the `thread.started` event and the answer from the last-message file.
+ */
+export function readCodex(path, events) {
     const started = events.find((event) => event.type === 'thread.started');
     const last = path.replace(/\.jsonl$/u, '-last.md');
     return {
@@ -50,7 +161,14 @@ function readCodex(path, events) {
         durationMs: undefined,
     };
 }
-function readErrors(path) {
+/**
+ * Reads the exit trailer launch.ts wrote to the errors file beside a journal.
+ *
+ * @param path - The journal path; the trailer sits beside it in `<name>.err`.
+ * @returns The exit code, whether the run was capped, and its duration; each is undefined when the
+ * file is absent or carries no trailer.
+ */
+export function readErrors(path) {
     const errors = path.replace(/\.jsonl$/u, '.err');
     if (!existsSync(errors))
         return { exit: undefined, capped: undefined, durationMs: undefined };
@@ -64,47 +182,66 @@ function readErrors(path) {
         durationMs: Number(match[3]),
     };
 }
-function describeEvent(event) {
+/**
+ * Describes an event by its type and subtype.
+ *
+ * @param event - The event, or undefined.
+ * @returns `type` or `type/subtype`, or undefined when there is no event.
+ */
+export function describeEvent(event) {
     if (event === undefined)
         return undefined;
     const type = readString(event, 'type');
     const subtype = readString(event, 'subtype');
     return subtype === undefined ? type : `${type}/${subtype}`;
 }
-function main(argv) {
-    const missing = readMissingFlags(argv, ['--cursor', '--claude', '--codex', '--out']);
+/**
+ * Runs the script on its arguments.
+ *
+ * @param argv - The arguments after the script path.
+ * @returns The exit code: 0 when the lane answered, 3 when it carries no session or answer, 64 on usage.
+ */
+export function main(argv) {
+    const unknown = readUnknownFlags(argv, FLAGS);
+    if (unknown.length > 0) {
+        console.error(`result: ${unknown.join(', ')} is not a flag this script reads; ${USAGE}`);
+        return 64;
+    }
+    const missing = readMissingFlags(argv, VALUE_FLAGS);
     if (missing.length > 0) {
         console.error(`result: ${missing.join(', ')} given with no value`);
         return 64;
     }
-    const modes = ['--cursor', '--claude', '--codex'].filter((flag) => argv.includes(flag));
+    const modes = MODE_FLAGS.filter((flag) => argv.includes(flag));
     const mode = modes[0];
     const path = mode === undefined ? undefined : readOption(argv, mode);
     const out = readOption(argv, '--out');
     if (modes.length !== 1 || mode === undefined || path === undefined || !existsSync(path)) {
-        console.error('usage: result.ts (--cursor JOURNAL | --claude JOURNAL | --codex JOURNAL) [--out PATH]; name one mode');
+        console.error(USAGE);
         return 64;
     }
     const events = readEvents(path);
-    const reading = mode === '--codex' ? readCodex(path, events) : readStream(events);
+    const result = mode === '--codex' ? readCodex(path, events) : readStream(events);
     const errors = readErrors(path);
     const stat = statSync(path);
-    if (reading.answer !== undefined && out !== undefined) {
+    if (result.answer !== undefined && out !== undefined) {
         mkdirSync(dirname(out), { recursive: true });
-        writeFileSync(out, reading.answer);
+        writeFileSync(out, result.answer);
     }
     console.log(JSON.stringify({
         journal: path,
-        session: reading.session,
-        durationMs: reading.durationMs ?? errors.durationMs,
+        session: result.session,
+        durationMs: result.durationMs ?? errors.durationMs,
         exit: errors.exit,
         capped: errors.capped,
         bytes: stat.size,
         ageMs: Math.max(0, Math.round(Date.now() - stat.mtimeMs)),
         lastEvent: describeEvent(events.at(-1)),
-        answerLength: reading.answer?.length ?? 0,
-        out: reading.answer === undefined ? undefined : out,
+        answerLength: result.answer?.length ?? 0,
+        out: result.answer === undefined ? undefined : out,
     }));
-    return reading.session === undefined || reading.answer === undefined ? 3 : 0;
+    return result.session === undefined || result.answer === undefined ? 3 : 0;
+}
+if (process.argv[1] !== undefined && realpathSync(process.argv[1]) === import.meta.filename) {
+    process.exitCode = main(process.argv.slice(2));
 }
-process.exitCode = main(process.argv.slice(2));