@botconnector/bccli 0.4.0-beta.5 → 0.4.0-beta.51

package/dist/chunk-N7KP6RNP.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import {
+  listAllModels
+} from "./chunk-QXOV4DUZ.js";
+import {
+  hasKey,
+  providerName,
+  removeGlobalProvider,
+  writeGlobalConfig
+} from "./chunk-2QYHSESB.js";
+import {
+  PRESETS,
+  loadConfig,
+  saveCredential
+} from "./chunk-NDEJUL44.js";
+import {
+  t
+} from "./chunk-XLC6T4SX.js";
+
+// src/providerCli.ts
+async function addProviderKey(providerId, key, deps) {
+  const config = loadConfig(deps.cwd, deps.env);
+  const [group] = await listAllModels(config, deps.env, { only: providerId, fetch: deps.fetch, keyOverride: key || void 0 });
+  if (!group || group.error) return { ok: false, error: t("The API key was rejected or {provider} could not be reached.", { provider: providerName(config, providerId) }) };
+  if (key) saveCredential(providerId, key, deps.env);
+  return { ok: true, models: group.models.length };
+}
+async function runProviderCommand(args, deps) {
+  const [action = "list", id] = args.subArgs;
+  const config = loadConfig(deps.cwd, deps.env);
+  if (action === "list") {
+    for (const pid of Object.keys(config.providers)) {
+      const mark = hasKey(config, pid, deps.env) ? "\u2713" : "\u25CB";
+      deps.out(`${mark} ${pid.padEnd(14)} ${providerName(config, pid).padEnd(20)} ${config.providers[pid].baseURL}`);
+    }
+    return 0;
+  }
+  if (!id) {
+    deps.err(t("Usage: bccli provider {action} <id>", { action }));
+    return 1;
+  }
+  if (action === "remove") {
+    removeGlobalProvider(id, deps.env);
+    deps.out(t("{id} removed.", { id }));
+    return 0;
+  }
+  if (action !== "add") {
+    deps.err(t("Unknown action: {action}. Use list, add, or remove.", { action }));
+    return 1;
+  }
+  const preset = PRESETS.find((p) => p.id === id);
+  if (!preset && !config.providers[id]) {
+    if (!args.url) {
+      deps.err(t("{id} is not a preset. For a custom provider add --url <OpenAI-compatible base URL>.", { id }));
+      return 1;
+    }
+    writeGlobalConfig(
+      { providers: { [id]: { baseURL: args.url, ...args.name ? { name: args.name } : {}, ...args.keyEnv ? { apiKeyEnv: args.keyEnv } : {} } } },
+      deps.env
+    );
+  }
+  const needsKey = !!loadConfig(deps.cwd, deps.env).providers[id].apiKeyEnv || !preset;
+  const key = needsKey ? await deps.readSecret(t("API key for {id} (leave empty if not needed): ", { id })) : "";
+  const result = await addProviderKey(id, key, deps);
+  if (!result.ok) {
+    deps.err(result.error);
+    return 1;
+  }
+  deps.out(t("{id} is ready. {n} models available.", { id, n: result.models }));
+  return 0;
+}
+
+export {
+  addProviderKey,
+  runProviderCommand
+};

package/dist/chunk-NDEJUL44.js

@@ -0,0 +1,361 @@
+#!/usr/bin/env node
+import {
+  t
+} from "./chunk-XLC6T4SX.js";
+
+// src/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/presets.ts
+var PRESETS = [
+  { id: "bc-cloud", name: "BotConnector Cloud", baseURL: "https://api.botconnector.id/v1", apiKeyEnv: "BOTCONNECTOR_API_KEY" },
+  { id: "openrouter", name: "OpenRouter", baseURL: "https://openrouter.ai/api/v1", apiKeyEnv: "OPENROUTER_API_KEY" },
+  { id: "openai", name: "OpenAI", baseURL: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY" },
+  { id: "gemini", name: "Google Gemini", baseURL: "https://generativelanguage.googleapis.com/v1beta/openai", apiKeyEnv: "GEMINI_API_KEY" },
+  { id: "deepseek", name: "DeepSeek", baseURL: "https://api.deepseek.com/v1", apiKeyEnv: "DEEPSEEK_API_KEY" },
+  { id: "groq", name: "Groq", baseURL: "https://api.groq.com/openai/v1", apiKeyEnv: "GROQ_API_KEY" },
+  { id: "ollama-cloud", name: "Ollama Cloud", baseURL: "https://ollama.com/v1", apiKeyEnv: "OLLAMA_API_KEY" },
+  { id: "ollama", name: "Ollama lokal", baseURL: "http://127.0.0.1:11434/v1", local: true },
+  { id: "lmstudio", name: "LM Studio lokal", baseURL: "http://127.0.0.1:1234/v1", local: true }
+];
+
+// src/keybinds.ts
+var KEYBIND_ACTIONS = ["thinking", "toolOutput", "pasteImage"];
+var DEFAULT_KEYBINDS = {
+  thinking: "ctrl+t",
+  toolOutput: "ctrl+o",
+  pasteImage: "alt+v"
+};
+function defaultKeybinds() {
+  return Object.fromEntries(KEYBIND_ACTIONS.map((action) => [action, parseKeybind(DEFAULT_KEYBINDS[action])]));
+}
+function parseKeybind(raw) {
+  const spec = raw.trim().toLowerCase();
+  const parts = spec.split("+");
+  const key = parts.pop() ?? "";
+  if (!/^[a-z]$/.test(key)) return void 0;
+  if (!parts.length || new Set(parts).size !== parts.length) return void 0;
+  if (parts.some((p) => p !== "ctrl" && p !== "alt")) return void 0;
+  return { spec, ctrl: parts.includes("ctrl"), meta: parts.includes("alt"), key };
+}
+function matchKeybind(kb, input, key) {
+  return kb.ctrl === !!key.ctrl && kb.meta === !!key.meta && input.toLowerCase() === kb.key;
+}
+
+// src/ui/theme.ts
+var THEMES = ["default", "blue", "amber", "magenta", "mono"];
+var REMAP = {
+  blue: { green: "blue" },
+  amber: { green: "yellow" },
+  magenta: { green: "magenta" }
+};
+var theme = "default";
+function setTheme(name) {
+  theme = name;
+}
+function color(name) {
+  if (process.env.NO_COLOR) return void 0;
+  if (theme === "mono") return void 0;
+  return REMAP[theme]?.[name] ?? name;
+}
+var ACCENT = "green";
+
+// src/config.ts
+var ConfigError = class extends Error {
+};
+var DEFAULT_MAX_STEPS = null;
+var DEFAULT_CONFIG = {
+  model: "bc-cloud/glm-5.3-flash",
+  permissionMode: "default",
+  reasoning: "auto",
+  vision: true,
+  networkPolicy: "allow",
+  keybinds: defaultKeybinds(),
+  verifyCommands: [],
+  repoMap: false,
+  theme: "default",
+  editor: "emacs",
+  sandbox: "off",
+  providers: Object.fromEntries(PRESETS.map((p) => [p.id, { baseURL: p.baseURL, apiKeyEnv: p.apiKeyEnv }])),
+  allow: []
+};
+function bccliHome(env = process.env) {
+  return env.BCCLI_HOME ?? join(homedir(), ".bccli");
+}
+function readJsonConfig(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new ConfigError(t("Invalid config: {path} ({error})", { path, error: error.message }));
+  }
+}
+function resolvedMaxSteps(global) {
+  const value = global.maxSteps;
+  if (value === void 0) return DEFAULT_MAX_STEPS;
+  if (value === null || value === 0) return null;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new ConfigError(t("maxSteps must be a positive number, or 0/null to disable the limit."));
+  }
+  return Math.max(1, Math.floor(value));
+}
+function resolvedSessionRetentionDays(global) {
+  const value = global.sessionRetentionDays;
+  if (value === void 0 || value === null || value === 0) return null;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new ConfigError(t("sessionRetentionDays must be a positive number of days, or 0/null to keep sessions."));
+  }
+  return Math.max(1, Math.floor(value));
+}
+function resolvedNetworkPolicy(global) {
+  const value = global.networkPolicy ?? "allow";
+  if (value !== "allow" && value !== "offline") {
+    throw new ConfigError(t('networkPolicy must be "allow" or "offline".'));
+  }
+  return value;
+}
+function resolvedPlugins(global) {
+  const value = global.plugins;
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new ConfigError(t("plugins must be an array of strings."));
+  }
+  return [...value];
+}
+function resolvedUpdateCheck(global) {
+  const value = global.updateCheck;
+  if (value === void 0) return void 0;
+  if (value !== "on" && value !== "off") throw new ConfigError(t('updateCheck must be "on" or "off".'));
+  return value;
+}
+function resolvedUsageCap(global) {
+  const cap = global.usageCap;
+  if (cap === void 0) return void 0;
+  if (typeof cap !== "object" || cap === null || Array.isArray(cap)) {
+    throw new ConfigError(t('usageCap must be an object, e.g. { "tokens": 2000000 }.'));
+  }
+  const { tokens, usd, prices } = cap;
+  const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+  const nonNegative = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+  if (tokens !== void 0 && !positive(tokens)) throw new ConfigError(t("usageCap.tokens must be a number greater than 0."));
+  if (usd !== void 0 && !positive(usd)) throw new ConfigError(t("usageCap.usd must be a number greater than 0."));
+  if (usd !== void 0 && (prices === void 0 || !Object.keys(prices).length)) {
+    throw new ConfigError(t("usageCap.usd requires usageCap.prices (USD per 1M tokens)."));
+  }
+  if (prices !== void 0) {
+    for (const [key, price] of Object.entries(prices)) {
+      if (!price || !nonNegative(price.input) || !nonNegative(price.output)) {
+        throw new ConfigError(t('usageCap.prices["{key}"] must have numeric input and output (USD per 1M tokens).', { key }));
+      }
+    }
+  }
+  if (tokens === void 0 && usd === void 0) throw new ConfigError(t("usageCap needs at least one of: tokens, usd."));
+  return { ...tokens !== void 0 ? { tokens } : {}, ...usd !== void 0 ? { usd } : {}, ...prices !== void 0 ? { prices } : {} };
+}
+function resolvedLsp(global) {
+  if (global.lsp === void 0) return void 0;
+  const lsp = global.lsp;
+  if (typeof global.lsp !== "object" || global.lsp === null || !Array.isArray(lsp.servers)) {
+    throw new ConfigError(t('lsp must be an object with a "servers" array.'));
+  }
+  for (const s of lsp.servers) {
+    const server = s;
+    if (typeof server?.command !== "string" || !server.command || !Array.isArray(server.extensions) || server.extensions.length === 0 || server.extensions.some((e) => typeof e !== "string" || !e.startsWith(".")) || server.args !== void 0 && (!Array.isArray(server.args) || server.args.some((a) => typeof a !== "string"))) {
+      throw new ConfigError(t('Each lsp server needs { "extensions": [".ts"], "command": "...", "args": ["..."] }.'));
+    }
+  }
+  return { servers: lsp.servers };
+}
+function resolvedSandbox(global) {
+  const value = global.sandbox ?? "off";
+  if (value !== "off" && value !== "on") throw new ConfigError(t('sandbox must be "off" or "on".'));
+  return value;
+}
+function resolvedEditor(global) {
+  const value = global.editor ?? "emacs";
+  if (value !== "emacs" && value !== "vim") throw new ConfigError(t('editor must be "emacs" or "vim".'));
+  return value;
+}
+function resolvedTheme(global) {
+  const value = global.theme ?? "default";
+  if (typeof value !== "string" || !THEMES.includes(value)) {
+    throw new ConfigError(t("theme must be one of: {themes}.", { themes: THEMES.join(", ") }));
+  }
+  return value;
+}
+function resolvedRepoMap(global) {
+  const value = global.repoMap ?? false;
+  if (typeof value !== "boolean") throw new ConfigError(t("repoMap must be true or false."));
+  return value;
+}
+function resolvedVerifyCommands(global) {
+  const value = global.verifyCommands;
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((c) => typeof c !== "string" || !c.trim())) {
+    throw new ConfigError(t("verifyCommands must be an array of non-empty strings."));
+  }
+  return value.map((c) => c.trim());
+}
+function resolvedKeybinds(global) {
+  const raw = global.keybinds ?? {};
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new ConfigError(t("keybinds must be an object mapping action to binding."));
+  }
+  const out = {};
+  for (const action of KEYBIND_ACTIONS) {
+    const spec = raw[action];
+    const value = spec === void 0 ? DEFAULT_KEYBINDS[action] : spec;
+    if (typeof value !== "string") {
+      throw new ConfigError(t('Keybind for "{action}" must be a string like "ctrl+t".', { action }));
+    }
+    const parsed = parseKeybind(value);
+    if (!parsed) {
+      throw new ConfigError(t('Keybind "{spec}" for "{action}" is invalid: use ctrl or alt plus one letter, e.g. "ctrl+t".', { spec: value, action }));
+    }
+    out[action] = parsed;
+  }
+  for (const key of Object.keys(raw)) {
+    if (!KEYBIND_ACTIONS.includes(key)) {
+      throw new ConfigError(t('Unknown keybind action "{action}". Known actions: {list}.', { action: key, list: KEYBIND_ACTIONS.join(", ") }));
+    }
+  }
+  return out;
+}
+function untrustedProviders(project, known) {
+  const out = {};
+  for (const [id, provider] of Object.entries(project.providers ?? {})) {
+    if (known[id] || typeof provider?.baseURL !== "string") continue;
+    out[id] = { baseURL: provider.baseURL };
+  }
+  return out;
+}
+function loadConfig(cwd, env = process.env) {
+  const global = readJsonConfig(join(bccliHome(env), "config.json"));
+  const project = readJsonConfig(join(cwd, ".bccli", "config.json"));
+  const known = { ...DEFAULT_CONFIG.providers, ...global.providers };
+  const fromProject = untrustedProviders(project, known);
+  return {
+    model: project.model ?? global.model ?? DEFAULT_CONFIG.model,
+    permissionMode: global.permissionMode ?? DEFAULT_CONFIG.permissionMode,
+    reasoning: global.reasoning ?? DEFAULT_CONFIG.reasoning,
+    thinkingVisible: global.thinkingVisible === true,
+    thinkingClickCollapse: global.thinkingClickCollapse === true,
+    sessionRetentionDays: resolvedSessionRetentionDays(global),
+    maxSteps: resolvedMaxSteps(global),
+    hooks: global.hooks,
+    vision: global.vision ?? DEFAULT_CONFIG.vision,
+    networkPolicy: resolvedNetworkPolicy(global),
+    plugins: resolvedPlugins(global),
+    keybinds: resolvedKeybinds(global),
+    verifyCommands: resolvedVerifyCommands(global),
+    repoMap: resolvedRepoMap(global),
+    theme: resolvedTheme(global),
+    editor: resolvedEditor(global),
+    sandbox: resolvedSandbox(global),
+    lsp: resolvedLsp(global),
+    usageCap: resolvedUsageCap(global),
+    updateCheck: resolvedUpdateCheck(global),
+    providers: { ...known, ...fromProject },
+    projectProviders: Object.keys(fromProject),
+    allow: [...global.allow ?? []]
+  };
+}
+function globalConfigPath(env = process.env) {
+  return join(bccliHome(env), "config.json");
+}
+function readGlobalPlugins(env = process.env) {
+  const raw = readJsonConfig(globalConfigPath(env));
+  const value = raw.plugins;
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new ConfigError(t("plugins must be an array of strings."));
+  }
+  return value;
+}
+function writeFileAtomic(path, data) {
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(tmp, data);
+    renameSync(tmp, path);
+  } catch (error) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function updateGlobalConfig(env, mutate) {
+  const path = globalConfigPath(env);
+  let cfg = {};
+  if (existsSync(path)) {
+    cfg = JSON.parse(readFileSync(path, "utf8"));
+  }
+  mutate(cfg);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileAtomic(path, `${JSON.stringify(cfg, null, 2)}
+`);
+}
+function readCredentials(env = process.env) {
+  const path = join(bccliHome(env), "credentials");
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveCredential(providerId, key, env = process.env) {
+  const home = bccliHome(env);
+  mkdirSync(home, { recursive: true });
+  const path = join(home, "credentials");
+  writeFileSync(path, JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+}
+function resolveModel(config, modelRef, env = process.env) {
+  const slash = modelRef.indexOf("/");
+  if (slash <= 0 || slash === modelRef.length - 1) {
+    throw new ConfigError(t("Model must be in provider/model format, e.g. bc-cloud/glm-5.3-flash (got: {ref})", { ref: modelRef }));
+  }
+  const providerId = modelRef.slice(0, slash);
+  const provider = config.providers[providerId];
+  if (!provider) {
+    throw new ConfigError(t('Provider "{id}" is not in the config. Available: {list}', { id: providerId, list: Object.keys(config.providers).join(", ") }));
+  }
+  const apiKey = (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[providerId] || void 0;
+  if (provider.apiKeyEnv && !apiKey) {
+    throw new ConfigError(t("No API key for {id} yet. Run `bccli login` or set the env var {env}.", { id: providerId, env: provider.apiKeyEnv }));
+  }
+  return { providerId, model: modelRef.slice(slash + 1), baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey };
+}
+function removeCredential(providerId, env = process.env) {
+  const creds = readCredentials(env);
+  if (!(providerId in creds)) return false;
+  delete creds[providerId];
+  const path = join(bccliHome(env), "credentials");
+  writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+  return true;
+}
+
+export {
+  PRESETS,
+  matchKeybind,
+  setTheme,
+  color,
+  ACCENT,
+  ConfigError,
+  DEFAULT_MAX_STEPS,
+  bccliHome,
+  readJsonConfig,
+  loadConfig,
+  globalConfigPath,
+  readGlobalPlugins,
+  updateGlobalConfig,
+  readCredentials,
+  saveCredential,
+  resolveModel,
+  removeCredential
+};

package/dist/chunk-PSO7R5AD.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/tools/types.ts
+function defineTool(tool) {
+  return tool;
+}
+
+export {
+  defineTool
+};

package/dist/chunk-QXOV4DUZ.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  hasKey,
+  providerName
+} from "./chunk-2QYHSESB.js";
+import {
+  createProvider
+} from "./chunk-R4BJBTWC.js";
+import {
+  PRESETS,
+  readCredentials
+} from "./chunk-NDEJUL44.js";
+import {
+  t
+} from "./chunk-XLC6T4SX.js";
+
+// src/models.ts
+function order(ids) {
+  const presetIds = PRESETS.map((p) => p.id);
+  const presets = presetIds.filter((id) => ids.includes(id));
+  const custom = ids.filter((id) => !presetIds.includes(id)).sort();
+  return [...presets, ...custom];
+}
+async function listAllModels(config, env = process.env, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const baseFetch = opts.fetch ?? fetch;
+  const untrusted = new Set(config.projectProviders ?? []);
+  const ids = order(Object.keys(config.providers)).filter((id) => opts.only ? id === opts.only : !untrusted.has(id) && hasKey(config, id, env));
+  const results = await Promise.all(
+    ids.map(async (id) => {
+      const provider = config.providers[id];
+      const apiKey = (opts.keyOverride && id === opts.only ? opts.keyOverride : void 0) || (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || readCredentials(env)[id] || void 0;
+      const local = !provider.apiKeyEnv;
+      const timedFetch = ((input, init) => baseFetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+      const list = createProvider({ baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey, model: "", fetch: timedFetch }).listModels();
+      let timer;
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+      });
+      try {
+        const models = await Promise.race([list, timeout]);
+        return { providerId: id, providerName: providerName(config, id), models };
+      } catch {
+        if (local && !opts.only) return void 0;
+        return { providerId: id, providerName: providerName(config, id), models: [], error: t("could not be reached") };
+      } finally {
+        clearTimeout(timer);
+      }
+    })
+  );
+  return results.filter((g) => !!g);
+}
+
+export {
+  listAllModels
+};

package/dist/chunk-QZKLZELZ.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+// src/tokenBudget.ts
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+var estimateMessages = (messages) => estimateTokens(JSON.stringify(messages));
+function trimToFit(messages, maxTokens) {
+  let out = messages;
+  while (estimateMessages(out) > maxTokens) {
+    const boundary = out.findIndex((m, i) => i > 0 && m.role === "user");
+    if (boundary === -1) return out;
+    out = out.slice(boundary);
+  }
+  return out;
+}
+function splitKeepRecent(messages, keepTokens) {
+  if (messages.length === 0) return [[], []];
+  let start = messages.length;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (i > 0 && messages[i].role !== "user") continue;
+    if (estimateMessages(messages.slice(i)) <= keepTokens) start = i;
+    else break;
+  }
+  if (start === messages.length) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].role === "user") {
+        start = i;
+        break;
+      }
+    }
+  }
+  return [messages.slice(0, start), messages.slice(start)];
+}
+var TOOL_STUB = "[Old tool result content cleared]";
+var TOOL_PRUNE_KEEP_TOKENS = 4e4;
+var TOOL_PRUNE_MIN_TOKENS = 2e4;
+var isToolStub = (content) => content.startsWith(TOOL_STUB);
+function pruneOldToolOutputs(messages) {
+  let kept = 0;
+  let oldTokens = 0;
+  const old = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role !== "tool" || isToolStub(m.content)) continue;
+    kept += estimateTokens(m.content);
+    if (kept > TOOL_PRUNE_KEEP_TOKENS) {
+      old.push(i);
+      oldTokens += estimateTokens(m.content);
+    }
+  }
+  if (oldTokens <= TOOL_PRUNE_MIN_TOKENS) return false;
+  for (const i of old) {
+    const m = messages[i];
+    messages[i] = { ...m, content: TOOL_STUB };
+  }
+  return true;
+}
+
+export {
+  estimateTokens,
+  estimateMessages,
+  trimToFit,
+  splitKeepRecent,
+  pruneOldToolOutputs
+};