@syntax-syllogism/aloop 0.5.2 → 0.6.0

package/src/adapters.mjs

@@ -16,9 +16,29 @@
  * treats the result as opaque text.
  */
 
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runCommand } from './command.mjs';
+
 /** Fields worth showing for a tool call, most specific first. */
 const toolSummaryFields = ['command', 'file_path', 'pattern', 'path', 'url', 'description', 'prompt'];
 
+export const PERMISSIONS = Object.freeze({
+  READ_ONLY: 'read-only',
+  WRITE_WORKTREE: 'write-worktree',
+  PUBLISH: 'publish',
+});
+
+/** Resolve a phase permission conservatively for adapters and BYO engines. */
+export function permissionLevel(permissions) {
+  const requested = Array.isArray(permissions) ? permissions : [];
+  if (requested.includes(PERMISSIONS.READ_ONLY)) return PERMISSIONS.READ_ONLY;
+  if (requested.includes(PERMISSIONS.WRITE_WORKTREE)) return PERMISSIONS.WRITE_WORKTREE;
+  if (requested.includes(PERMISSIONS.PUBLISH)) return PERMISSIONS.PUBLISH;
+  return PERMISSIONS.READ_ONLY;
+}
+
 function condense(text, limit = 120) {
   const flat = text.replace(/\s+/g, ' ').trim();
   return flat.length > limit ? `${flat.slice(0, limit - 1)}\u2026` : flat;
@@ -51,6 +71,17 @@ function summarizeAgyParams(params) {
   return '';
 }
 
+function cliVersion(command) {
+  return async () => {
+    const cwd = await mkdtemp(join(tmpdir(), 'aloop-version-'));
+    try {
+      return (await runCommand(command, ['--version'], { cwd, timeoutMs: 5000 })).stdout.trim();
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  };
+}
+
 function renderClaudeBlock(block) {
   if (block.type === 'text') return block.text?.trim() ? `${block.text.trimEnd()}\n` : '';
   if (block.type === 'thinking') return '  \u00b7 thinking\n';
@@ -141,10 +172,39 @@ export function renderAgyEvent(event) {
  */
 export function createJsonlRenderer(renderEvent) {
   let pending = '';
+  let usage = null;
+  const recordUsage = (event) => {
+    if (!event || typeof event !== 'object') return;
+    const source = event.usage ?? event.result?.usage ?? event;
+    if (!source || typeof source !== 'object') return;
+    const tokenValues = [
+      source.tokens,
+      source.total_tokens,
+      source.totalTokens,
+      source.input_tokens !== undefined && source.output_tokens !== undefined
+        ? Number(source.input_tokens) + Number(source.output_tokens)
+        : undefined,
+      source.prompt_tokens !== undefined && source.completion_tokens !== undefined
+        ? Number(source.prompt_tokens) + Number(source.completion_tokens)
+        : undefined,
+    ].filter((value) => Number.isFinite(value));
+    const cost = [event.usage, event.result?.usage, event]
+      .filter((candidate) => candidate && typeof candidate === 'object')
+      .flatMap((candidate) => [candidate.cost, candidate.total_cost, candidate.totalCost, candidate.total_cost_usd])
+      .find((value) => Number.isFinite(value));
+    if (tokenValues.length || cost !== undefined) {
+      usage = {
+        ...(tokenValues.length ? { tokens: tokenValues.at(-1) } : usage?.tokens !== undefined ? { tokens: usage.tokens } : {}),
+        ...(cost !== undefined ? { cost } : usage?.cost !== undefined ? { cost: usage.cost } : {}),
+      };
+    }
+  };
   const renderLine = (line) => {
     if (!line.trim()) return '';
     try {
-      return renderEvent(JSON.parse(line));
+      const event = JSON.parse(line);
+      recordUsage(event);
+      return renderEvent(event);
     } catch {
       return `${line}\n`;
     }
@@ -161,6 +221,9 @@ export function createJsonlRenderer(renderEvent) {
       pending = '';
       return renderLine(rest);
     },
+    usage() {
+      return usage;
+    },
   };
 }
 
@@ -171,9 +234,11 @@ export function passthroughRenderer() {
 
 const claudeAdapter = {
   name: 'claude',
+  version: cliVersion('claude'),
   efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
-  command({ prompt, addDirs, agent = {} }) {
-    // `auto`, not `acceptEdits`: under acceptEdits a non-interactive `-p` run
+  command({ prompt, addDirs, permissions, artifactOnly = false, agent = {} }) {
+    // `auto`, not `acceptEdits`, is used for worktree-writing and
+    // artifact-only phases: under acceptEdits a non-interactive `-p` run
     // auto-denies every Bash call, because there is no one to answer the
     // prompt it raises. Phases that have to build, test, and commit then spin
     // until the timeout kills them.
@@ -181,7 +246,9 @@ const claudeAdapter = {
     // the process exits, so a phase that runs for half an hour looks identical
     // to one that has hung. stream-json emits an event per step, which
     // `createRenderer` turns back into readable lines.
-    const args = ['-p', prompt, '--permission-mode', 'auto', '--output-format', 'stream-json', '--verbose'];
+    const canWrite = permissionLevel(permissions) === PERMISSIONS.WRITE_WORKTREE || artifactOnly;
+    const permissionMode = canWrite ? 'auto' : 'plan';
+    const args = ['-p', prompt, '--permission-mode', permissionMode, '--output-format', 'stream-json', '--verbose'];
     if (agent.model) args.push('--model', agent.model);
     if (agent.effort) args.push('--effort', agent.effort);
     for (const dir of addDirs) args.push('--add-dir', dir);
@@ -192,9 +259,12 @@ const claudeAdapter = {
 
 const codexAdapter = {
   name: 'codex',
+  version: cliVersion('codex'),
   efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
-  command({ prompt, cwd, addDirs, agent = {} }) {
-    const args = ['exec', prompt, '--sandbox', 'workspace-write', '--cd', cwd];
+  command({ prompt, cwd, addDirs, permissions, artifactOnly = false, agent = {} }) {
+    const canWrite = permissionLevel(permissions) === PERMISSIONS.WRITE_WORKTREE || artifactOnly;
+    const sandbox = canWrite ? 'workspace-write' : 'read-only';
+    const args = ['exec', prompt, '--sandbox', sandbox, '--cd', cwd];
     if (agent.model) args.push('--model', agent.model);
     if (agent.effort) args.push('-c', `model_reasoning_effort=${JSON.stringify(agent.effort)}`);
     for (const dir of addDirs) args.push('--add-dir', dir);
@@ -204,8 +274,9 @@ const codexAdapter = {
 
 const agyAdapter = {
   name: 'agy',
+  version: cliVersion('agy'),
   efforts: ['low', 'medium', 'high'],
-  command({ prompt, addDirs, timeoutMs, agent = {} }) {
+  command({ prompt, addDirs, timeoutMs, permissions, artifactOnly = false, agent = {} }) {
     // `--dangerously-skip-permissions`, not bare `accept-edits`: in headless
     // `--print` mode agy cannot prompt for the `command` permission its Bash-
     // style tools need, so it auto-denies the first one and exits 0 having done
@@ -218,12 +289,13 @@ const agyAdapter = {
     // from a hang (the run log shows only the header). stream-json emits an
     // event per step, which `createRenderer` turns back into readable lines —
     // same reasoning as the claude adapter above.
+    const canWrite = permissionLevel(permissions) === PERMISSIONS.WRITE_WORKTREE || artifactOnly;
     const args = [
       '--print', prompt,
-      '--mode', 'accept-edits',
-      '--dangerously-skip-permissions',
+      '--mode', canWrite ? 'accept-edits' : 'plan',
       '--output-format', 'stream-json',
     ];
+    if (canWrite) args.splice(4, 0, '--dangerously-skip-permissions');
     if (agent.model) args.push('--model', agent.model);
     if (agent.effort) args.push('--effort', agent.effort);
     if (timeoutMs) args.push('--print-timeout', `${Math.ceil(timeoutMs / 1000)}s`);
@@ -245,6 +317,9 @@ function validateConfiguredAdapter(name, adapter) {
   if (adapter.createRenderer !== undefined && typeof adapter.createRenderer !== 'function') {
     throw new Error(`Invalid adapter "${name}": createRenderer must be a function.`);
   }
+  if (adapter.version !== undefined && typeof adapter.version !== 'function') {
+    throw new Error(`Invalid adapter "${name}": version must be a function.`);
+  }
   return adapter;
 }
 

package/src/backends/gitlab.mjs

@@ -0,0 +1,231 @@
+import { runCommand } from '../command.mjs';
+import { GitFacade } from '../git.mjs';
+import { PublishError } from '../publish.mjs';
+
+const DRAFT_RE = /^(draft:\s*|wip:\s*)/i;
+const NO_MERGE_REQUEST_RE = /\b(?:no merge requests? found|merge requests? not found|merge requests? (?:do|does) not exist)\b/i;
+
+/**
+ * @typedef {object} GitLabMr
+ * @property {number} iid
+ * @property {string} web_url
+ * @property {string} target_branch
+ * @property {string} sha - The merge request head commit SHA.
+ * @property {boolean} [draft]
+ * @property {boolean} [work_in_progress] - Legacy GitLab draft field.
+ */
+
+/**
+ * @typedef {object} GitLabTransport
+ * @property {(ctx: { host: string }) => Promise<void>} checkAuth
+ * @property {(ctx: { host: string, project: string, branch: string }) => Promise<GitLabMr|null>} getMergeRequest
+ * @property {(ctx: { host: string, project: string, sourceBranch: string, targetBranch: string, title: string, description: string, descriptionFilePath?: string, draft: boolean }) => Promise<void>} createMergeRequest
+ * @property {(ctx: { host: string, project: string, iid: number, branch: string, title: string, description: string, descriptionFilePath?: string, draft: boolean }) => Promise<void>} updateMergeRequest
+ */
+
+/**
+ * Parse the URL forms emitted by Git, retaining a self-hosted port in `host`.
+ * GitLab project paths may contain any number of namespace segments.
+ */
+export function parseGitLabRemoteUrl(remoteUrl) {
+  if (typeof remoteUrl !== 'string' || !remoteUrl.trim()) {
+    throw new PublishError('Configured GitLab remote is not a valid Git remote URL.');
+  }
+
+  const value = remoteUrl.trim();
+  let host;
+  let project;
+  if (/^[a-z][a-z\d+.-]*:\/\//i.test(value)) {
+    let parsed;
+    try {
+      parsed = new URL(value);
+    } catch (error) {
+      throw new PublishError(`Configured GitLab remote is not a valid Git remote URL: ${value}`, { cause: error });
+    }
+    if (!['http:', 'https:', 'ssh:'].includes(parsed.protocol) || !parsed.host) {
+      throw new PublishError(`Configured GitLab remote is not a valid Git remote URL: ${value}`);
+    }
+    host = parsed.host;
+    project = parsed.pathname;
+  } else {
+    const match = /^git@(?:(\[[^\]]+\])|([^:/]+)):(.+)$/i.exec(value);
+    if (!match) {
+      throw new PublishError(`Configured GitLab remote is not a valid Git remote URL: ${value}`);
+    }
+    host = match[1] ?? match[2];
+    project = match[3];
+    // Git's scp-like syntax has no standard port notation. Accept the common
+    // git@host:2222/group/project form while keeping normal namespace paths.
+    const portMatch = /^(\d+)\/(.+)$/.exec(project);
+    if (portMatch) {
+      host = `${host}:${portMatch[1]}`;
+      project = portMatch[2];
+    }
+  }
+
+  project = project.replace(/^\/+|\/+$/g, '').replace(/\.git$/i, '');
+  if (!host || !project || project.split('/').some((segment) => !segment)) {
+    throw new PublishError(`Configured GitLab remote is not a valid Git remote URL: ${value}`);
+  }
+  return { host, project };
+}
+
+export const withDraftPrefix = (title) => DRAFT_RE.test(title) ? title : `Draft: ${title}`;
+export const withoutDraftPrefix = (title) => title.replace(DRAFT_RE, '');
+
+function errorText(error) {
+  return [error?.output, error?.stderr, error?.cause?.output, error?.message]
+    .filter(Boolean)
+    .join('\n');
+}
+
+/**
+ * The default GitLab transport. `glab` is intentionally an external runtime
+ * requirement, so consumers can replace this transport with REST or MCP code.
+ */
+export function glabTransport({ cwd, runner = runCommand, env } = {}) {
+  async function run(args) {
+    try {
+      return await runner('glab', args, { cwd, ...(env ? { env } : {}) });
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new PublishError('GitLab publishing requires the `glab` CLI, but it is not installed.', { cause: error });
+      }
+      throw new PublishError(errorText(error).trim() || 'GitLab CLI command failed.', { cause: error });
+    }
+  }
+
+  const repository = (host, project) => `https://${host}/${project}`;
+  const descriptionArgs = (description, descriptionFilePath) => descriptionFilePath
+    ? ['--description-file', descriptionFilePath]
+    : ['--description', description];
+
+  return {
+    async checkAuth({ host }) {
+      await run(['auth', 'status', '--hostname', host]);
+    },
+
+    async getMergeRequest({ host, project, branch }) {
+      try {
+        const result = await run(['mr', 'view', branch, '--output', 'json', '--repo', repository(host, project)]);
+        return JSON.parse(result.stdout);
+      } catch (error) {
+        const output = errorText(error);
+        if (error.cause?.code === 'ENOENT') throw error;
+        // Only the CLI's explicit no-MR messages mean it is safe to create one.
+        // Other exit-code-1 failures, such as permissions or connectivity, must
+        // reach publish() instead of being mistaken for an absent MR.
+        if (NO_MERGE_REQUEST_RE.test(output)) {
+          return null;
+        }
+        throw new PublishError(`Unable to inspect GitLab merge request for ${branch}: ${error.message}`, { cause: error });
+      }
+    },
+
+    async createMergeRequest({ host, project, sourceBranch, targetBranch, title, description, descriptionFilePath, draft }) {
+      const args = [
+        'mr', 'create',
+        '--repo', repository(host, project),
+        '--source-branch', sourceBranch,
+        '--target-branch', targetBranch,
+        '--title', title,
+        ...descriptionArgs(description, descriptionFilePath),
+        ...(draft ? ['--draft'] : []),
+        '--yes',
+      ];
+      await run(args);
+    },
+
+    async updateMergeRequest({ host, project, iid, title, description, descriptionFilePath, draft }) {
+      const args = [
+        'mr', 'update', String(iid),
+        '--repo', repository(host, project),
+        '--title', title,
+        ...descriptionArgs(description, descriptionFilePath),
+        draft ? '--draft' : '--ready',
+        '--yes',
+      ];
+      await run(args);
+    },
+  };
+}
+
+/**
+ * Adapt GitLab-native merge request data to aloop's verified pull-request port.
+ *
+ * @param {{ cwd: string, git?: GitFacade, transport?: GitLabTransport, env?: object }} options
+ */
+export function gitlabBackend({ cwd, git = new GitFacade(cwd), transport, env } = {}) {
+  transport ??= glabTransport({ cwd, env });
+  const repositories = new Map();
+
+  async function resolveRepository(remote) {
+    if (!repositories.has(remote)) {
+      const remoteUrl = await git.remoteUrl(remote);
+      repositories.set(remote, parseGitLabRemoteUrl(remoteUrl));
+    }
+    return repositories.get(remote);
+  }
+
+  async function mergeRequest(remote, branch) {
+    const { host, project } = await resolveRepository(remote);
+    return { host, project, mr: await transport.getMergeRequest({ host, project, branch }) };
+  }
+
+  function mapMergeRequest(mr) {
+    if (!mr) return null;
+    return {
+      url: mr.web_url,
+      baseRefName: mr.target_branch,
+      headRefOid: mr.sha,
+      isDraft: mr.draft ?? mr.work_in_progress ?? false,
+      number: Number(mr.iid),
+    };
+  }
+
+  return {
+    async precheck({ remote }) {
+      try {
+        const { host } = await resolveRepository(remote);
+        await transport.checkAuth({ host });
+      } catch (error) {
+        throw new PublishError(`GitLab publishing precheck failed: ${error.message}`, { cause: error });
+      }
+    },
+
+    async view({ remote, branch }) {
+      return mapMergeRequest((await mergeRequest(remote, branch)).mr);
+    },
+
+    async create({ remote, base, branch, title, body, bodyFilePath, draft }) {
+      const { host, project } = await resolveRepository(remote);
+      await transport.createMergeRequest({
+        host,
+        project,
+        sourceBranch: branch,
+        targetBranch: base,
+        title: draft ? withDraftPrefix(title) : withoutDraftPrefix(title),
+        description: body,
+        descriptionFilePath: bodyFilePath,
+        draft,
+      });
+    },
+
+    async update({ remote, branch, title, body, bodyFilePath, draft }) {
+      const { host, project, mr } = await mergeRequest(remote, branch);
+      if (!mr) throw new PublishError(`No GitLab merge request exists for branch ${branch}.`);
+      const iid = Number(mr.iid);
+      if (!Number.isInteger(iid)) throw new PublishError(`GitLab merge request for branch ${branch} has no valid IID.`);
+      await transport.updateMergeRequest({
+        host,
+        project,
+        iid,
+        branch,
+        title: draft ? withDraftPrefix(title) : withoutDraftPrefix(title),
+        description: body,
+        descriptionFilePath: bodyFilePath,
+        draft,
+      });
+    },
+  };
+}

package/src/command.mjs

@@ -1,4 +1,115 @@
 import { spawn } from 'node:child_process';
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+import { win32 as windowsPath } from 'node:path';
+
+export function signalProcessGroup(pid, signal, {
+  platform = process.platform,
+  spawnImpl = spawn,
+  onFailure,
+} = {}) {
+  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
+  if (platform === 'win32') {
+    const handleFailure = onFailure ?? (() => {
+      try {
+        process.kill(pid, signal);
+      } catch (error) {
+        if (error.code !== 'ESRCH') throw error;
+      }
+    });
+    let killer;
+    try {
+      killer = spawnImpl('taskkill', ['/PID', String(pid), '/T', '/F'], {
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+    } catch {
+      handleFailure();
+      return false;
+    }
+    const addListener = killer?.once ?? killer?.on;
+    if (!addListener) {
+      handleFailure();
+      return false;
+    }
+    let completed = false;
+    const fail = () => {
+      if (completed) return;
+      completed = true;
+      handleFailure();
+    };
+    addListener.call(killer, 'error', fail);
+    addListener.call(killer, 'close', (code) => {
+      if (completed) return;
+      completed = true;
+      if (code !== 0) handleFailure();
+    });
+    killer?.unref?.();
+    return true;
+  }
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch (error) {
+    if (error.code !== 'ESRCH') throw error;
+    return false;
+  }
+}
+
+const WINDOWS_EXECUTABLE_EXTENSIONS = ['.COM', '.EXE', '.BAT', '.CMD', '.PS1'];
+
+function environmentValue(env, name) {
+  if (env[name] !== undefined) return env[name];
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key ? env[key] : undefined;
+}
+
+export function resolveWindowsExecutable(command, env = process.env, { fileExists = existsSync } = {}) {
+  const pathEntries = (environmentValue(env, 'PATH') ?? '').split(';').filter(Boolean);
+  const pathExtensions = (environmentValue(env, 'PATHEXT') ?? WINDOWS_EXECUTABLE_EXTENSIONS.join(';'))
+    .split(';')
+    .map((extension) => extension.trim().toUpperCase())
+    .filter(Boolean);
+  const hasDirectory = command.includes('\\') || command.includes('/');
+  const bases = hasDirectory ? [command] : pathEntries.map((directory) => windowsPath.join(directory, command));
+  const extensions = windowsPath.extname(command) ? [''] : pathExtensions;
+
+  for (const base of bases) {
+    for (const extension of extensions) {
+      const candidate = `${base}${extension}`;
+      if (fileExists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+function windowsSpawnSpec(command, args, env, resolveExecutable) {
+  const resolved = resolveExecutable(command, env) ?? command;
+  const extension = windowsPath.extname(resolved).toLowerCase();
+  if (extension === '.cmd' || extension === '.bat') {
+    return {
+      command: environmentValue(env, 'ComSpec') ?? 'cmd.exe',
+      args: ['/d', '/s', '/c', resolved, ...args],
+    };
+  }
+  if (extension === '.ps1') {
+    return {
+      command: environmentValue(env, 'SystemRoot')
+        ? windowsPath.join(environmentValue(env, 'SystemRoot'), 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+        : 'powershell.exe',
+      args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', resolved, ...args],
+    };
+  }
+  return { command: resolved, args };
+}
+
+function clearActiveProcess(path) {
+  if (!path) return;
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+}
 
 /**
  * Run a command, capturing its output while optionally streaming it onward.
@@ -9,17 +120,56 @@ import { spawn } from 'node:child_process';
  * most common unattended failure and it burns tokens for as long as it hangs.
  */
 export async function runCommand(command, args = [], options = {}) {
-  const { cwd, env = process.env, timeoutMs, onOutput, input } = options;
+  const {
+    cwd,
+    env = process.env,
+    timeoutMs,
+    onOutput,
+    input,
+    activeProcessPath,
+    platform = process.platform,
+    spawnImpl = spawn,
+    resolveExecutable = resolveWindowsExecutable,
+  } = options;
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { cwd, env });
+    const spawnSpec = platform === 'win32' ? windowsSpawnSpec(command, args, env, resolveExecutable) : { command, args };
+    const child = spawnImpl(spawnSpec.command, spawnSpec.args, {
+      cwd,
+      env,
+      detached: platform !== 'win32',
+      ...(platform === 'win32' ? { windowsVerbatimArguments: false } : {}),
+    });
+    if (activeProcessPath) {
+      writeFileSync(activeProcessPath, `${JSON.stringify({
+        pid: child.pid,
+        ...(platform !== 'win32' ? { processGroupId: child.pid } : {}),
+      })}\n`);
+    }
     let stdout = '';
     let stderr = '';
     let timedOut = false;
 
+    const timeoutError = (cause) => {
+      const error = new Error(`Command timed out after ${timeoutMs}ms: ${command} ${args.join(' ')}`, { cause });
+      error.code = 'ETIMEDOUT';
+      return decorate(error);
+    };
+
     const timer = timeoutMs
       ? setTimeout(() => {
           timedOut = true;
-          child.kill('SIGKILL');
+          const killDirectChild = () => {
+            try {
+              if (child.kill('SIGKILL') === false) reject(timeoutError());
+            } catch (error) {
+              reject(timeoutError(error));
+            }
+          };
+          if (!signalProcessGroup(child.pid, 'SIGKILL', {
+            platform,
+            spawnImpl,
+            onFailure: killDirectChild,
+          })) killDirectChild();
         }, timeoutMs)
       : null;
 
@@ -36,6 +186,7 @@ export async function runCommand(command, args = [], options = {}) {
 
     const decorate = (error) => {
       if (timer) clearTimeout(timer);
+      clearActiveProcess(activeProcessPath);
       error.command = [command, ...args].join(' ');
       error.stdout = stdout;
       error.stderr = stderr;
@@ -47,10 +198,9 @@ export async function runCommand(command, args = [], options = {}) {
     child.on('error', (error) => reject(decorate(error)));
     child.on('close', (code, signal) => {
       if (timer) clearTimeout(timer);
+      clearActiveProcess(activeProcessPath);
       if (timedOut) {
-        const error = decorate(new Error(`Command timed out after ${timeoutMs}ms: ${command} ${args.join(' ')}`));
-        error.code = 'ETIMEDOUT';
-        return reject(error);
+        return reject(timeoutError());
       }
       if (code === 0) return resolve({ stdout, stderr, code });
       const error = decorate(new Error(`Command failed: ${command} ${args.join(' ')}${stderr ? `\n${stderr}` : ''}`));