copilot-operator 0.1.0

package/dist/src/exec/runner.js

@@ -0,0 +1,245 @@
+/**
+ * Runs one step in a Windows shell and captures everything it produced.
+ *
+ * The hard case this is built for: a step that runs an automated test suite. Such a step
+ * can legitimately take an hour, and a naive wall-clock timeout would kill a perfectly
+ * healthy run. So there are two independent clocks:
+ *
+ *   hardTimeoutMs   absolute ceiling. A run that exceeds it is killed, no matter what.
+ *   idleTimeoutMs   how long the process may produce NO output at all before it is
+ *                   considered hung. This is the clock that actually matters: a test suite
+ *                   printing a line every few seconds resets it forever, while a genuinely
+ *                   stuck process trips it quickly.
+ *
+ * Output is streamed to disk as it arrives, so a killed step still reports everything it
+ * managed to print. Nothing is buffered in memory only.
+ *
+ * Which shell a step runs in is not decided here. It is decided in `shells.ts`, for steps and
+ * post-task checks alike, and this module only carries the answer out again in the result —
+ * what was asked for, what it ran in, and the executable that was actually started — because a
+ * run that behaved oddly is usually a run that was read by an interpreter nobody looked at.
+ */
+import { spawn } from 'node:child_process';
+import { createWriteStream, existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { effectiveShell, invocationFor, missingShellProblem, resolveShell } from './shells.js';
+import { stopTree } from './processes.js';
+import { stepEnvironment } from './stepEnv.js';
+const DEFAULT_HARD_TIMEOUT_MS = 4 * 60 * 60 * 1000;
+const DEFAULT_IDLE_TIMEOUT_MS = 15 * 60 * 1000;
+const HEARTBEAT_EVERY_MS = 30_000;
+/** Cap on what is held in memory and echoed into the report body. */
+const MAX_CAPTURE_CHARS = 200_000;
+/**
+ * The result of a step that never started because the machine has no shell for it.
+ *
+ * Shaped like a spawn error, because that is what it would have been a moment later, and with
+ * the problem attached so that whoever is counting attempts can see this one does not count.
+ */
+function unrunnable(req, problem) {
+    return {
+        id: req.id,
+        // What it would have run in, which on a machine with nothing installed is only a name.
+        shell: effectiveShell(req.shell),
+        requestedShell: req.shell ?? null,
+        shellPath: '',
+        shellProblem: problem,
+        command: req.command,
+        exitCode: -2,
+        outcome: 'spawn-error',
+        durationMs: 0,
+        stdout: '',
+        stderr: `[runner] the command was not run: ${problem.message}\n`,
+        truncated: false,
+        logPath: '',
+        lastOutputAgoMs: 0,
+    };
+}
+/**
+ * The longest a step that is being stopped may take before its result is given anyway. The stop
+ * itself is `taskkill /T`, a grace period, then `/F` (see `processes.ts`), which with reading the
+ * process table comes to about ten seconds at worst; this is the ceiling on
+ * waiting for it, so that a stop that itself hangs cannot hang the task.
+ */
+const STOP_CEILING_MS = 30_000;
+export async function runStep(req, 
+/**
+ * `tracker` records the shell this step starts, which is what later lets the runner tell the
+ * processes the bot started from ones the operator started by hand. See `processes.ts`.
+ */
+opts = {}) {
+    const hardTimeoutMs = req.hardTimeoutMs ?? DEFAULT_HARD_TIMEOUT_MS;
+    const idleTimeoutMs = req.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    const startedAt = Date.now();
+    // Every path into the shell goes through here, which is what makes a step and a post-task
+    // check incapable of disagreeing about which interpreter their commands were read by.
+    const choice = resolveShell(req.shell);
+    if (!choice.ok)
+        return unrunnable(req, choice.problem);
+    const resolved = choice.resolved;
+    await mkdir(dirname(req.logPath), { recursive: true });
+    const log = createWriteStream(req.logPath, { flags: 'a' });
+    /*
+     * A step log that cannot be written must never take the process down with it.
+     *
+     * Without a listener, a stream error is an unhandled 'error' event, which in Node is an
+     * uncaught exception: a full disk, a locked file or a write that lands after the stream has
+     * ended would kill the API in the middle of a run. The log is a record of a step, not the
+     * step itself, so losing a line of it is the smallest possible failure and is treated as one.
+     */
+    log.on('error', () => undefined);
+    log.write(`# step ${req.id} shell=${resolved.shell} exe=${resolved.path} cwd=${req.cwd}\n# ${req.command}\n`);
+    const { file, args } = invocationFor(resolved, req.command, req.scriptArgs);
+    return await new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let bytesOut = 0;
+        let truncated = false;
+        let lastLine = '';
+        let lastOutputAt = Date.now();
+        let settled = false;
+        /** Set when the shell itself would not start, which is not a failure of the command. */
+        let shellProblem;
+        // PowerShell colours its output with ANSI escapes, which then travel to Copilot inside
+        // the report as `ESC[32;1m` noise around every value. NO_COLOR is honoured by
+        // PowerShell 7 and by most modern tools, and was verified to produce clean output here.
+        const child = spawn(file, args, {
+            cwd: req.cwd,
+            // Named, not inherited: a step must not see the bot's own token or whatever else the
+            // operator's shell holds. See `stepEnv.ts`.
+            env: stepEnvironment(req.env ?? process.env, req.passEnv),
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        if (child.pid)
+            opts.tracker?.started(child.pid);
+        /** Set once the runner has decided to stop the step, so the process exiting reports why. */
+        let stopping = null;
+        const finish = (outcome, exitCode) => {
+            if (settled)
+                return;
+            settled = true;
+            if (child.pid)
+                opts.tracker?.ended(child.pid);
+            clearInterval(heartbeat);
+            clearTimeout(hardTimer);
+            clearInterval(idleTimer);
+            opts.signal?.removeEventListener('abort', onAbort);
+            log.end(`\n# outcome=${outcome} exit=${exitCode} durationMs=${Date.now() - startedAt}\n`);
+            resolve({
+                id: req.id,
+                shell: resolved.shell,
+                requestedShell: resolved.requested,
+                shellPath: resolved.path,
+                shellProblem,
+                command: req.command,
+                exitCode,
+                outcome,
+                durationMs: Date.now() - startedAt,
+                stdout,
+                stderr,
+                truncated,
+                logPath: req.logPath,
+                lastOutputAgoMs: Date.now() - lastOutputAt,
+            });
+        };
+        const capture = (chunk, stream) => {
+            const text = chunk.toString('utf8');
+            lastOutputAt = Date.now();
+            bytesOut += chunk.length;
+            // Output can still arrive after the child has closed and the step has been settled: the
+            // pipes flush independently of the close event. Writing then would be a write to an
+            // ended stream, so the tail goes to the captured text and not to the file.
+            if (!settled)
+                log.write(stream === 'err' ? text.replace(/^/gm, '[stderr] ') : text);
+            const trimmed = text.trimEnd();
+            const nl = trimmed.lastIndexOf('\n');
+            if (trimmed)
+                lastLine = nl >= 0 ? trimmed.slice(nl + 1) : trimmed;
+            const target = stream === 'out' ? stdout : stderr;
+            if (target.length >= MAX_CAPTURE_CHARS) {
+                truncated = true;
+                return;
+            }
+            const room = MAX_CAPTURE_CHARS - target.length;
+            const slice = text.length > room ? text.slice(0, room) : text;
+            if (slice.length < text.length)
+                truncated = true;
+            if (stream === 'out')
+                stdout += slice;
+            else
+                stderr += slice;
+        };
+        child.stdout.on('data', (c) => capture(c, 'out'));
+        child.stderr.on('data', (c) => capture(c, 'err'));
+        child.on('error', (err) => {
+            stderr += `\n[runner] failed to start: ${String(err)}\n`;
+            /*
+             * ENOENT here is usually the interpreter — `spawn` never got as far as reading what it was
+             * given — and that is worth saying plainly, because the one thing that must not happen next
+             * is the task treating it as work that failed and trying again.
+             *
+             * It is not always the interpreter, though, and Windows makes the two indistinguishable
+             * from the error alone. A `cwd` that does not exist raises ENOENT as well, and Node writes
+             * the *executable's* name into the message while doing it: `spawn cmd.exe ENOENT` for a
+             * directory that was simply never created. A step or a check pointed at a folder an earlier
+             * step was supposed to make would then close the task with a sentence about PowerShell not
+             * being installed — false, and worse than false, because an environment fault is never sent
+             * back to the chat and the chat is the only thing that could have created the folder. So
+             * the two are told apart by the one fact that separates them: whether the executable is
+             * still where detection found it.
+             */
+            const enoent = err.code === 'ENOENT';
+            if (enoent && !existsSync(resolved.path))
+                shellProblem = missingShellProblem(resolved);
+            finish('spawn-error', -2);
+        });
+        // While the runner is stopping the step the process exiting is the stop working, not the step
+        // completing, so the reason recorded is the runner's.
+        child.on('close', (code) => (stopping ? finish(stopping.outcome, stopping.exitCode) : finish('completed', code ?? -1)));
+        /*
+         * Stops the step's whole tree — `taskkill /T`, then `/F` — and gives the result only
+         * once it is down, so the next step does not start while this one still holds a port or a
+         * file. It used to be `taskkill /T /F` at once, which is TerminateProcess: no handler runs, and a
+         * dev server or a test runner is cut off mid-write.
+         */
+        const stop = (outcome, exitCode, why) => {
+            if (stopping || settled)
+                return;
+            stopping = { outcome, exitCode };
+            stderr += `\n[runner] ${why}, stopping the process tree (asked to close, then forced)\n`;
+            clearTimeout(hardTimer);
+            clearInterval(idleTimer);
+            const ceiling = setTimeout(() => finish(outcome, exitCode), STOP_CEILING_MS);
+            const pid = child.pid;
+            void (pid ? stopTree(pid, startedAt) : Promise.resolve())
+                .catch(() => undefined)
+                .finally(() => {
+                clearTimeout(ceiling);
+                finish(outcome, exitCode);
+            });
+        };
+        const hardTimer = setTimeout(() => {
+            stop('hard-timeout', -1, `hard timeout after ${Math.round(hardTimeoutMs / 1000)}s`);
+        }, hardTimeoutMs);
+        const idleTimer = setInterval(() => {
+            if (Date.now() - lastOutputAt < idleTimeoutMs)
+                return;
+            stop('idle-timeout', -1, `no output for ${Math.round(idleTimeoutMs / 1000)}s, treating as hung`);
+        }, Math.min(idleTimeoutMs, 30_000));
+        const heartbeat = setInterval(() => {
+            opts.onHeartbeat?.({
+                id: req.id,
+                elapsedMs: Date.now() - startedAt,
+                idleMs: Date.now() - lastOutputAt,
+                bytesOut,
+                lastLine,
+            });
+        }, HEARTBEAT_EVERY_MS);
+        const onAbort = () => {
+            stop('aborted', -3, 'aborted by the user');
+        };
+        opts.signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}

package/dist/src/exec/scriptFiles.js

@@ -0,0 +1,81 @@
+/**
+ * The script files a command line runs, read so that what is in them passes the same gate as the
+ * line itself.
+ *
+ * The contract tells the chat to write a long script into the project with `Set-Content` and run
+ * it in the next step with `pwsh -File`. The file's text is then screened twice: once as the text
+ * of the step that wrote it, and — since 2026-09-27 — again here, as the file on disk, when a step
+ * runs it. The second reading is the one that counts: it sees the file as it is, not as it was
+ * described.
+ *
+ * Two rules follow from that:
+ *
+ *   - A step that both writes a script and runs it is refused. The contract already says write in
+ *     one step, run in the next; only then does the file exist to be read at the gate.
+ *   - A step that runs a script the gate cannot read — the file is missing, or larger than a step's
+ *     worth of text — is refused with that reason rather than run on trust.
+ *
+ * Covered: PowerShell scripts given to `-File`, dot-sourced, or called with `&` or by path. Not
+ * covered, and stated so: a `.js`, `.py` or `.cs` file a project's own tools run. Those are the
+ * project's code, and this runner has never claimed to read it; the boundary there is isolation.
+ */
+import { readFileSync, statSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+/** Larger than this is not a step's script; it is not read, and running it is refused. */
+const MAX_SCRIPT_BYTES = 256 * 1024;
+/** Paths of PowerShell scripts this command line runs, as written. */
+export function scriptPathsRun(command) {
+    const paths = new Set();
+    const patterns = [
+        /\b(?:pwsh|powershell)(?:\.exe)?\b[^|;\n]*?\s-(?:File|f)\s+(?:"([^"]+)"|'([^']+)'|(\S+))/gi,
+        /(?:^|[|;&(\n{]\s*)(?:[.&]\s+)?(?:"([^"]+\.ps1)"|'([^']+\.ps1)'|(\S+\.ps1))(?=\s|$)/gi,
+    ];
+    for (const re of patterns) {
+        for (const m of command.matchAll(re)) {
+            const p = (m[1] ?? m[2] ?? m[3] ?? '').trim();
+            if (p && /\.ps1$/i.test(p))
+                paths.add(p);
+        }
+    }
+    return [...paths];
+}
+/** Whether the command also writes a PowerShell script — with a cmdlet or a redirection. */
+export function writesScript(command) {
+    return /\b(Set-Content|Add-Content|Out-File|New-Item|Copy-Item|Move-Item|Rename-Item|sc|ac|cp|copy|mv|move|ren|ni)\b[^|;\n]*\.ps1\b|>\s*["']?[^\s"']*\.ps1\b/i.test(command);
+}
+/** Reads the scripts a command runs, relative to `cwd`. */
+export function scriptFilesRun(command, cwd) {
+    return scriptPathsRun(command).map((p) => {
+        const path = isAbsolute(p) ? p : resolve(cwd, p);
+        try {
+            const size = statSync(path).size;
+            if (size > MAX_SCRIPT_BYTES)
+                return { path, text: null, problem: `${path} is ${size} bytes, larger than a step's script` };
+            return { path, text: readFileSync(path, 'utf8') };
+        }
+        catch {
+            return { path, text: null, problem: `${path} does not exist yet, so its contents cannot be read before it runs` };
+        }
+    });
+}
+/**
+ * Why the scripts this line runs must not run, or null. `screen` is the gate applied to each
+ * script's text — the same one the command line went through.
+ */
+export function scriptFileRefusal(command, cwd, screen) {
+    const paths = scriptPathsRun(command);
+    if (paths.length === 0)
+        return null;
+    if (writesScript(command)) {
+        return ('refused: this step writes a script and runs it in the same line. Write the file in one step and run it in the ' +
+            'next, so that what is in the file can be read before it runs.');
+    }
+    for (const file of scriptFilesRun(command, cwd)) {
+        if (file.text === null)
+            return `refused: ${file.problem}. Write the file in an earlier step, then run it.`;
+        const reason = screen(file.text);
+        if (reason)
+            return `${reason} (in the script ${file.path})`;
+    }
+    return null;
+}

package/dist/src/exec/shellExecuteTrap.js

@@ -0,0 +1,221 @@
+/**
+ * `Start-Process npx` does not start npx.
+ *
+ * PowerShell resolves a bare command name through PATH and, inside a directory, takes a `.ps1`
+ * before a `.cmd` of the same name. Node ships `npm.ps1` and `npx.ps1` next to their `.cmd`
+ * twins, and every `npm install -g` adds another pair (`pnpm.ps1`, `pnpx.ps1`). Typed inline,
+ * `npx tsx src/main.ts`, that is exactly right: the script runs in the shell that found it.
+ * Handed to `Start-Process` it is not. Start-Process gives anything that is not an executable
+ * to ShellExecute, and the Windows shell then does whatever `.ps1` is associated with on that
+ * machine: here "This command cannot be run completely because the system cannot find all the
+ * information required", or a "Select an app to open this .ps1 file" dialog that nobody is
+ * sitting in front of. Either way no server starts, and the step that then polls the port
+ * reports "connection refused" against work that was fine.
+ *
+ * On 2026-09-20 thirteen review steps started a server this way and one hung on the dialog
+ * until the hard timeout (91 s). The reviewer contract's own example had taught the form, and
+ * the model reproduced it faithfully, so the contract is fixed too; this file is what makes the
+ * refusal mechanical, because a rule that lives only in prose is advice.
+ *
+ * The rule is exact rather than a list of names: a name is a trap when the PATH search
+ * PowerShell itself performs would land on a `.ps1` for it, in the same directories and the
+ * same order. `node`, `pwsh`, `cmd.exe` and a name that is not on PATH at all pass through:
+ * the first two resolve to an `.exe`, the last fails fast and clearly on its own.
+ */
+import { existsSync } from 'node:fs';
+import { extname, join } from 'node:path';
+/** Start-Process parameters that take a value, so the token after them is not the target. */
+const VALUE_PARAMETERS = [
+    'ArgumentList',
+    'Args',
+    'FilePath',
+    'Path',
+    'Credential',
+    'WorkingDirectory',
+    'wd',
+    'Verb',
+    'WindowStyle',
+    'RedirectStandardError',
+    'RedirectStandardInput',
+    'RedirectStandardOutput',
+    'RSE',
+    'RSI',
+    'RSO',
+    'Environment',
+];
+/** Cached PATH lookups: the search is cheap, but a step can name the same command many times. */
+const shimCache = new Map();
+const SHIM_CACHE_MS = 60_000;
+/**
+ * The `.ps1` that PowerShell would run for a bare `name`, or null when it would run an
+ * application (or nothing). Walks PATH in order; in each directory a `.ps1` wins over any
+ * PATHEXT extension, and the first directory that has the name in any form decides.
+ */
+export function scriptShimFor(name, env = process.env) {
+    const path = env.PATH ?? env.Path ?? '';
+    const key = `${path}\u0000${name.toLowerCase()}`;
+    const cached = shimCache.get(key);
+    if (cached && Date.now() - cached.at < SHIM_CACHE_MS)
+        return cached.hit;
+    const pathext = (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
+    let hit = null;
+    for (const dir of path.split(';').map((d) => d.trim()).filter(Boolean)) {
+        const script = join(dir, `${name}.ps1`);
+        if (existsSync(script)) {
+            hit = script;
+            break;
+        }
+        if (pathext.some((ext) => existsSync(join(dir, `${name}${ext}`))))
+            break;
+    }
+    shimCache.set(key, { at: Date.now(), hit });
+    return hit;
+}
+/** For tests, which build their own PATH and must not read a stale answer. */
+export function forgetScriptShims() {
+    shimCache.clear();
+}
+/**
+ * Splits one PowerShell statement into tokens: whitespace-separated, quotes kept together,
+ * parentheses and braces kept together at depth, and the statement cut at the first `;`, `|`,
+ * newline or closing bracket that belongs to an enclosing construct.
+ */
+function tokenize(text) {
+    const tokens = [];
+    let cur = '';
+    let quoted = false;
+    let quote = null;
+    let depth = 0;
+    const push = () => {
+        if (cur)
+            tokens.push({ text: cur, quoted });
+        cur = '';
+        quoted = false;
+    };
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '\r' && !quote)
+            continue;
+        if (quote) {
+            cur += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            quoted = true;
+            cur += ch;
+            continue;
+        }
+        if (ch === '(' || ch === '{' || ch === '[')
+            depth += 1;
+        if (ch === ')' || ch === '}' || ch === ']') {
+            if (depth === 0)
+                break;
+            depth -= 1;
+        }
+        if (depth === 0 && (ch === ';' || ch === '|' || ch === '\n' || ch === '\r')) {
+            if (ch === '\n' && cur.endsWith('`')) {
+                cur = cur.slice(0, -1);
+                push();
+                continue;
+            }
+            break;
+        }
+        if (depth === 0 && /\s/.test(ch)) {
+            push();
+            continue;
+        }
+        cur += ch;
+    }
+    push();
+    return tokens;
+}
+function takesValue(parameter) {
+    const p = parameter.toLowerCase();
+    return VALUE_PARAMETERS.some((full) => full.toLowerCase().startsWith(p));
+}
+/** The target of one Start-Process invocation whose text starts right after the cmdlet name. */
+function targetOf(rest) {
+    const tokens = tokenize(rest);
+    for (let i = 0; i < tokens.length; i += 1) {
+        const t = tokens[i];
+        if (!t.quoted && t.text.startsWith('-')) {
+            const [name, inlineValue] = t.text.slice(1).split(':', 2);
+            const isFilePath = 'filepath'.startsWith(name.toLowerCase()) || 'path'.startsWith(name.toLowerCase());
+            if (inlineValue !== undefined) {
+                if (isFilePath)
+                    return inlineValue;
+                continue;
+            }
+            if (!takesValue(name))
+                continue;
+            const value = tokens[i + 1];
+            if (!value)
+                return null;
+            if (isFilePath)
+                return value.text;
+            // A comma-separated list written with spaces (`'a', 'b'`) continues past the first token.
+            let j = i + 1;
+            while (tokens[j]?.text.endsWith(',') && tokens[j + 1])
+                j += 1;
+            i = j;
+            continue;
+        }
+        return t.text;
+    }
+    return null;
+}
+/**
+ * Every Start-Process target in a command line. The alias forms `start` and `saps` count only
+ * where a command can begin, so the `'start'` inside an argument list is not mistaken for one.
+ */
+export function startProcessTargets(command) {
+    const out = [];
+    const re = /(?:\bStart-Process\b|(?<=^|[;{(|=&]|\n)\s*\b(?:start|saps)\b(?!-))/gi;
+    let m;
+    while ((m = re.exec(command)) !== null) {
+        const target = targetOf(command.slice(m.index + m[0].length));
+        if (target)
+            out.push(target.replace(/^['"]|['"]$/g, ''));
+    }
+    return out;
+}
+/** Bare means: no directory, no extension, no expression — the shell has to look it up. */
+function isBareName(target) {
+    return /^[A-Za-z0-9_.-]+$/.test(target) && !/[\\/:]/.test(target) && extname(target) === '' && !target.includes('$');
+}
+/**
+ * Why a command must not run as written, or null. The full cmdlet name is checked in any shell,
+ * because a `cmd` step can wrap `powershell -Command "Start-Process npx"` and fall into the same
+ * hole; the short aliases exist only in PowerShell.
+ */
+export function findShellExecuteTrap(command, shell = 'pwsh', env = process.env) {
+    if (!/start-process|\b(?:start|saps)\b/i.test(command))
+        return null;
+    const targets = shell === 'cmd'
+        ? startProcessTargets(command.replace(/(?<=^|[;{(|=&]|\n)\s*\b(?:start|saps)\b(?!-)/gi, ''))
+        : startProcessTargets(command);
+    for (const target of targets) {
+        if (extname(target).toLowerCase() === '.ps1') {
+            return (`\`Start-Process ${target}\` hands a .ps1 to the Windows shell, which fails ("cannot find all the ` +
+                `information required") or opens a "Select an app" dialog nobody is there to answer. Run the script ` +
+                `with its interpreter: \`Start-Process pwsh -ArgumentList '-NoProfile','-File','${target}'\`, or inline with \`& '${target}'\`.`);
+        }
+        if (!isBareName(target))
+            continue;
+        const shim = scriptShimFor(target, env);
+        if (!shim)
+            continue;
+        const twin = shim.replace(/\.ps1$/i, '.cmd');
+        const named = existsSync(twin) ? `'${target}.cmd'` : `the .cmd or .exe, with its extension`;
+        return (`\`Start-Process ${target}\` would not start ${target}: PowerShell resolves the bare name to ${shim}, ` +
+            `and Start-Process hands a .ps1 to the Windows shell, which fails ("cannot find all the information required") ` +
+            `or opens a "Select an app" dialog nobody is there to answer, so the step hangs until its timeout and nothing ` +
+            `listens on the port. Name the file: \`Start-Process -FilePath ${named} -ArgumentList ...\` — that PID is a ` +
+            `wrapper's, stop the tree with \`taskkill /PID $p.Id /T /F\` — or start the program itself ` +
+            `(\`Start-Process node -ArgumentList 'dist/main.js'\`). Inline, \`${target} ...\` runs fine in the shell.`);
+    }
+    return null;
+}