@z0ne/installer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 z0ne.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# @z0ne/installer
+
+Point coding agents at [z0ne.ai](https://z0ne.ai) — one API key, every model.
+
+```
+npx @z0ne/installer
+```
+
+The wizard validates your key against the live gateway, detects which tools
+you have installed, lets you pick models from the live catalog, and writes
+each tool's config — merging with what you already have, never clobbering it.
+
+## Supported tools
+
+| Tool        | What gets written                                             |
+| ----------- | ------------------------------------------------------------- |
+| Claude Code | `~/.claude/settings.json` (Anthropic wire format, model slots)|
+| Codex CLI   | `~/.codex/config.toml` + `auth.json` + token helper           |
+| OpenCode    | `~/.config/opencode/opencode.json` (openai-compatible provider)|
+| Cline       | `~/.cline/data/globalState.json` + `secrets.json`             |
+| Hermes TaskCreate| `~/.hermes/config.yaml` + `~/.hermes/.env`                    |
+| OpenClaw    | `~/.openclaw/openclaw.json` (+ per-agent `models.json`)       |
+
+Optionally installs a **statusline for Claude Code** (model · session cost ·
+project dir) — rendered from local session data only, no network calls.
+
+## Non-interactive use
+
+```
+npx @z0ne/installer --key sk-... --tools claude,codex --yes
+npx @z0ne/installer --tools codex --model gpt-5.6-sol --yes        # key from Z0NE_API_KEY
+npx @z0ne/installer uninstall --tools claude,codex --yes
+```
+
+Run `npx @z0ne/installer --help` for all flags.
+
+## Safety
+
+- Every file the installer changes is backed up first to
+  `<file>.bak.<timestamp>` next to the original.
+- Configs are merged, not replaced: your other providers, comments
+  (Codex TOML), and unrelated settings survive.
+- The API key is stored only where each tool itself expects it, with
+  owner-only permissions where the platform supports it.
+- `uninstall` removes exactly what `install` added.
+
+## Windows note (Codex)
+
+Codex on Windows can only spawn `.cmd`/`.exe` auth helpers — a `.sh` helper
+fails with os error 193 and Codex silently skips fetching the live model
+catalog, leaving only its bundled models in the picker. The installer writes
+a `.cmd` token helper with absolute paths baked in, so the full z0ne.ai
+catalog shows up in the Codex model picker out of the box.
+
+## License
+
+MIT © z0ne.ai

package/bin/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+"use strict";
+
+require("../lib/main.js")
+  .run(process.argv.slice(2))
+  .catch((error) => {
+    process.stderr.write("z0ne-installer: " + (error && error.message ? error.message : error) + "\n");
+    process.exit(1);
+  });

package/lib/api.js

@@ -0,0 +1,59 @@
+"use strict";
+// z0ne.ai gateway API: key validation + live model catalog.
+
+const DEFAULT_BASE = "https://api.z0ne.ai";
+
+// Normalize a user-supplied base URL to the bare origin form (no trailing
+// slash, no /v1 suffix). Tool modules append what each agent expects.
+function normalizeBase(raw) {
+  let base = (raw || DEFAULT_BASE).trim().replace(/\/+$/, "");
+  base = base.replace(/\/v1$/, "");
+  if (!/^https?:\/\//.test(base)) base = "https://" + base;
+  return base;
+}
+
+// GET /v1/models with the pasted key. Success doubles as key validation.
+// Returns the enriched data rows: {id, vendor, context_length, input_modalities, ...}
+async function fetchModels(base, key) {
+  let res;
+  try {
+    res = await fetch(base + "/v1/models", {
+      headers: { Authorization: "Bearer " + key, "User-Agent": "z0ne-installer" },
+    });
+  } catch (error) {
+    throw new Error("could not reach " + base + " (" + error.message + ")");
+  }
+  if (res.status === 401 || res.status === 403) {
+    throw new Error("API key rejected (HTTP " + res.status + "). Get a key at https://console.z0ne.ai/keys");
+  }
+  if (!res.ok) throw new Error("gateway returned HTTP " + res.status);
+  const body = await res.json();
+  const rows = Array.isArray(body.data) ? body.data : [];
+  if (!rows.length) throw new Error("gateway returned an empty model list");
+  return rows;
+}
+
+// First id matching any pattern, in order of preference.
+function pickDefault(ids, patterns, fallback) {
+  for (const p of patterns) {
+    const hit = ids.find((id) => p.test(id));
+    if (hit) return hit;
+  }
+  return fallback || ids[0];
+}
+
+function defaultModels(ids) {
+  return {
+    model: pickDefault(ids, [/^gpt-5\.6-sol$/, /^gpt-5\.6/, /^gpt-/]),
+    opus: pickDefault(ids, [/^claude-opus-5$/, /^claude-fable-5$/, /^claude-opus-4-8$/, /^claude-opus/]),
+    sonnet: pickDefault(ids, [/^claude-sonnet-5$/, /^claude-sonnet-4-6$/, /^claude-sonnet/]),
+    haiku: pickDefault(ids, [/^claude-haiku-4-5$/, /^claude-haiku/]),
+  };
+}
+
+const fmtCtx = (n) => {
+  if (!n || typeof n !== "number") return "";
+  return n >= 1000 ? Math.round(n / 1000) + "k ctx" : n + " ctx";
+};
+
+module.exports = { DEFAULT_BASE, normalizeBase, fetchModels, pickDefault, defaultModels, fmtCtx };

package/lib/fsutil.js

@@ -0,0 +1,88 @@
+"use strict";
+// Filesystem + detection helpers shared by all tool modules.
+// Every file we modify is backed up once per run to <file>.bak.<timestamp>.
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync } = require("child_process");
+
+const isWindows = os.platform() === "win32";
+const home = () => os.homedir();
+
+const runStamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
+const backedUp = new Set();
+
+// Copy <file> to <file>.bak.<stamp> before the first write of this run.
+// Returns the backup path, or null when there was nothing to back up.
+function backupFile(file) {
+  if (backedUp.has(file)) return null;
+  backedUp.add(file);
+  if (!fs.existsSync(file)) return null;
+  const bak = file + ".bak." + runStamp;
+  fs.copyFileSync(file, bak);
+  return bak;
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readText(file) {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+// Parse errors abort on purpose: merging on top of a file we could not parse
+// would silently destroy the user's own configuration.
+function readJson(file) {
+  const content = readText(file);
+  if (content === null) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(file + " exists but is not valid JSON — fix or remove it, then re-run.");
+  }
+}
+
+function writeText(file, content) {
+  ensureDir(path.dirname(file));
+  const bak = backupFile(file);
+  fs.writeFileSync(file, content.endsWith("\n") ? content : content + "\n");
+  return bak;
+}
+
+function writeJson(file, obj) {
+  return writeText(file, JSON.stringify(obj, null, 2));
+}
+
+// `which`/`where` with %APPDATA%\npm injected on Windows so npm globals resolve.
+function commandExists(cmd) {
+  try {
+    const probe = isWindows ? "where " + cmd : "which " + cmd;
+    const env = isWindows
+      ? { ...process.env, PATH: process.env.APPDATA + "\\npm;" + process.env.PATH }
+      : process.env;
+    execSync(probe, { stdio: "pipe", windowsHide: true, env });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  isWindows,
+  home,
+  runStamp,
+  backupFile,
+  ensureDir,
+  readText,
+  readJson,
+  writeText,
+  writeJson,
+  commandExists,
+};

package/lib/main.js

@@ -0,0 +1,281 @@
+"use strict";
+// @z0ne/installer — wizard entry point.
+// install (default): validate key -> pick tools -> pick models -> write configs.
+// uninstall:         remove z0ne.ai settings from selected tools.
+
+const ui = require("./ui");
+const { fmt } = ui;
+const api = require("./api");
+const { home } = require("./fsutil");
+
+const TOOLS = [
+  require("./tools/claude"),
+  require("./tools/codex"),
+  require("./tools/opencode"),
+  require("./tools/cline"),
+  require("./tools/hermes"),
+  require("./tools/openclaw"),
+];
+
+const VERSION = require("../package.json").version;
+const byId = (id) => TOOLS.find((t) => t.id === id);
+const shortHome = (p) => p.replace(home(), "~").replace(/\\/g, "/");
+
+const HELP = `
+  npx @z0ne/installer [uninstall] [options]
+
+  Points coding agents at the z0ne.ai gateway. Interactive by default;
+  every flag below makes one step non-interactive.
+
+  options
+    --key <sk-...>        z0ne.ai API key (or env Z0NE_API_KEY)
+    --base-url <url>      gateway base (default https://api.z0ne.ai)
+    --tools <a,b,c>       ${TOOLS.map((t) => t.id).join(", ")}
+    --model <id>          default model for OpenAI-format tools
+    --opus <id>           Claude Code opus-slot model
+    --sonnet <id>         Claude Code sonnet-slot model
+    --haiku <id>          Claude Code haiku-slot model
+    --statusline          install the Claude Code statusline without asking
+    --no-statusline       skip the Claude Code statusline without asking
+    --yes                 skip the final confirmation
+    --help, --version
+
+  Every file the installer changes is backed up first to
+  <file>.bak.<timestamp>. Undo anytime: npx @z0ne/installer uninstall
+`;
+
+const VALUED_FLAGS = ["key", "k", "base-url", "tools", "model", "opus", "sonnet", "haiku"];
+
+function parseArgs(argv) {
+  const flags = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("-")) {
+      flags._.push(a);
+      continue;
+    }
+    const eq = a.indexOf("=");
+    const name = (eq === -1 ? a : a.slice(0, eq)).replace(/^--?/, "");
+    let val = eq === -1 ? true : a.slice(eq + 1);
+    if (val === true && VALUED_FLAGS.includes(name) && argv[i + 1] !== undefined && !argv[i + 1].startsWith("-")) {
+      val = argv[++i];
+    }
+    flags[name] = val;
+  }
+  return flags;
+}
+
+function banner() {
+  ui.log();
+  ui.log("  " + fmt.bold("Z0NE.AI") + fmt.gray("  installer v" + VERSION));
+  ui.log(fmt.gray("  one key, every model - api.z0ne.ai"));
+  ui.log();
+}
+
+const hintOf = (row) => {
+  if (!row) return "";
+  const bits = [];
+  if (row.vendor) bits.push(row.vendor);
+  const ctx = api.fmtCtx(row.context_length);
+  if (ctx) bits.push(ctx);
+  return bits.join(" - ");
+};
+
+function parseToolsFlag(raw) {
+  const toolIds = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  const bad = toolIds.filter((id) => !byId(id));
+  if (bad.length) {
+    throw new Error("unknown tool(s): " + bad.join(", ") + " (valid: " + TOOLS.map((t) => t.id).join(", ") + ")");
+  }
+  return toolIds;
+}
+
+async function resolveKeyAndModels(flags) {
+  const base = api.normalizeBase(
+    (typeof flags["base-url"] === "string" && flags["base-url"]) || process.env.Z0NE_BASE_URL
+  );
+  let key =
+    (typeof flags.key === "string" && flags.key) ||
+    (typeof flags.k === "string" && flags.k) ||
+    process.env.Z0NE_API_KEY ||
+    "";
+
+  for (let attempt = 0; ; attempt++) {
+    if (!key) {
+      key = await ui.askHidden("Paste your z0ne.ai API key (from https://console.z0ne.ai/keys):");
+      if (!key) throw new Error("no API key provided (use --key or Z0NE_API_KEY)");
+    }
+    ui.info("validating key against " + base + " ...");
+    try {
+      const rows = await api.fetchModels(base, key);
+      ui.ok("API key valid - " + rows.length + " models available");
+      return { base, key, rows };
+    } catch (error) {
+      ui.err(error.message);
+      if (!ui.isInteractive() || attempt >= 2) throw new Error("could not validate the API key");
+      key = "";
+    }
+  }
+}
+
+async function install(flags) {
+  const { base, key, rows } = await resolveKeyAndModels(flags);
+  const ids = rows.map((r) => r.id);
+  const rowsById = Object.fromEntries(rows.map((r) => [r.id, r]));
+  const defs = api.defaultModels(ids);
+  const modelItems = ids.map((id) => ({ value: id, label: id, hint: hintOf(rowsById[id]) }));
+
+  // 1. which tools
+  let toolIds;
+  if (typeof flags.tools === "string") {
+    toolIds = parseToolsFlag(flags.tools);
+  } else {
+    const detected = TOOLS.filter((t) => t.detect()).map((t) => t.id);
+    const items = TOOLS.map((t) => ({
+      value: t.id,
+      label: t.title,
+      hint: (detected.includes(t.id) ? "detected - " : "") + t.hint,
+    }));
+    ui.log();
+    toolIds = await ui.selectMany(
+      "Which tools should use z0ne.ai?",
+      items,
+      detected.length ? detected : TOOLS.map((t) => t.id)
+    );
+  }
+  if (!toolIds.length) {
+    ui.warn("nothing selected - exiting.");
+    return;
+  }
+
+  // 2. default model for OpenAI-format tools
+  const openaiTools = toolIds.filter((id) => id !== "claude");
+  let model = typeof flags.model === "string" ? flags.model : defs.model;
+  if (openaiTools.length && typeof flags.model !== "string" && ui.isInteractive()) {
+    ui.log();
+    model = await ui.selectOne("Default model (" + openaiTools.join(", ") + ")", modelItems, defs.model);
+  }
+  if (model && !ids.includes(model)) {
+    ui.warn('model "' + model + '" is not in the live catalog - using it anyway');
+  }
+
+  // 3. Claude Code model slots
+  let opus = typeof flags.opus === "string" ? flags.opus : defs.opus;
+  let sonnet = typeof flags.sonnet === "string" ? flags.sonnet : defs.sonnet;
+  let haiku = typeof flags.haiku === "string" ? flags.haiku : defs.haiku;
+  const slotsFlagged = ["opus", "sonnet", "haiku"].some((f) => typeof flags[f] === "string");
+  if (toolIds.includes("claude") && !slotsFlagged && ui.isInteractive()) {
+    ui.log();
+    const keep = await ui.confirm(
+      "Claude Code slots: opus=" + opus + ", sonnet=" + sonnet + ", haiku=" + haiku + ". Use these?",
+      true
+    );
+    if (!keep) {
+      opus = await ui.selectOne("Opus-slot model", modelItems, opus);
+      sonnet = await ui.selectOne("Sonnet-slot model", modelItems, sonnet);
+      haiku = await ui.selectOne("Haiku-slot model", modelItems, haiku);
+    }
+  }
+
+  // 4. statusline (Claude Code only)
+  let statusline = false;
+  if (toolIds.includes("claude")) {
+    if (flags.statusline === true) statusline = true;
+    else if (flags["no-statusline"] === true) statusline = false;
+    else statusline = await ui.confirm("Install the z0ne statusline for Claude Code?", true);
+  }
+
+  // 5. summary + confirm
+  ui.log();
+  ui.log("  " + fmt.bold("About to configure"));
+  for (const id of toolIds) {
+    const t = byId(id);
+    const detail =
+      id === "claude"
+        ? "opus=" + opus + " sonnet=" + sonnet + " haiku=" + haiku + (statusline ? " +statusline" : "")
+        : "model=" + model;
+    ui.info(t.title + "  " + fmt.gray(t.hint + " - " + detail));
+  }
+  ui.info("gateway " + base + fmt.gray(" - changed files are backed up to *.bak.<timestamp>"));
+  if (flags.yes !== true && !(await ui.confirm("Proceed?", true))) {
+    ui.warn("aborted - nothing written.");
+    return;
+  }
+
+  // 6. apply
+  const ctx = { base, key, model, opus, sonnet, haiku, statusline, rowsById };
+  ui.log();
+  let failed = 0;
+  for (const id of toolIds) {
+    const t = byId(id);
+    try {
+      const res = t.apply(ctx);
+      ui.ok(t.title + "  ->  " + res.paths.map(shortHome).join(", "));
+      for (const n of res.notes) ui.warn(t.title + ": " + n);
+    } catch (error) {
+      failed++;
+      ui.err(t.title + ": " + error.message);
+    }
+  }
+
+  ui.log();
+  if (failed) ui.warn(failed + " tool(s) failed - see above. The rest are configured.");
+  else ui.ok(fmt.bold("Done.") + " Open a new terminal so fresh configs are picked up.");
+  const tryCmds = toolIds
+    .map((id) => ({ claude: "claude", codex: "codex", opencode: "opencode", cline: "cline", hermes: "hermes", openclaw: "openclaw" })[id])
+    .filter(Boolean);
+  if (tryCmds.length) ui.info("try it: " + tryCmds.join(" / "));
+  ui.info("undo anytime: npx @z0ne/installer uninstall");
+  if (failed) process.exitCode = 1;
+}
+
+async function uninstall(flags) {
+  let toolIds;
+  if (typeof flags.tools === "string") {
+    toolIds = parseToolsFlag(flags.tools);
+  } else {
+    const detected = TOOLS.filter((t) => t.detect()).map((t) => t.id);
+    const items = TOOLS.map((t) => ({
+      value: t.id,
+      label: t.title,
+      hint: (detected.includes(t.id) ? "detected - " : "") + t.hint,
+    }));
+    toolIds = await ui.selectMany("Remove z0ne.ai settings from:", items, detected);
+  }
+  if (!toolIds.length) {
+    ui.warn("nothing selected - exiting.");
+    return;
+  }
+  if (flags.yes !== true && !(await ui.confirm("Remove z0ne.ai settings from " + toolIds.join(", ") + "?", true))) {
+    ui.warn("aborted - nothing changed.");
+    return;
+  }
+  ui.log();
+  for (const id of toolIds) {
+    const t = byId(id);
+    try {
+      const res = t.remove();
+      ui.ok(t.title + (res.paths.length ? "  ->  cleaned " + res.paths.map(shortHome).join(", ") : ""));
+      for (const n of res.notes) ui.info(t.title + ": " + n);
+    } catch (error) {
+      ui.err(t.title + ": " + error.message);
+      process.exitCode = 1;
+    }
+  }
+  ui.log();
+  ui.ok("Uninstall finished. Backups (*.bak.<timestamp>) were left in place.");
+}
+
+async function run(argv) {
+  const flags = parseArgs(argv);
+  if (flags.help === true || flags.h === true) return ui.log(HELP);
+  if (flags.version === true || flags.v === true) return ui.log(VERSION);
+
+  const cmd = flags._[0] || "install";
+  banner();
+  if (cmd === "install") return install(flags);
+  if (cmd === "uninstall") return uninstall(flags);
+  throw new Error('unknown command "' + cmd + '" (try --help)');
+}
+
+module.exports = { run };

package/lib/toml.js

@@ -0,0 +1,114 @@
+"use strict";
+// Line-based TOML merge helpers for Codex's config.toml.
+// A full TOML round-trip would drop the user's comments and formatting, so we
+// edit lines in place instead: replace a key inside its section when present,
+// append it otherwise, and never touch unrelated lines.
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// TOML basic-string literal (paths are pre-normalized to forward slashes).
+const tstr = (s) => '"' + String(s).replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+
+// Set `key = value` inside [section] (or top level when section is null).
+// The section range ends at the NEXT bracket header of any kind, so inserted
+// keys can never leak into a following subsection.
+function setTomlKey(text, key, value, section) {
+  const lines = text ? text.split(/\r?\n/) : [];
+  let start = null;
+  let end = lines.length;
+
+  if (section) {
+    for (let i = 0; i < lines.length; i++) {
+      const stripped = lines[i].trim();
+      if (start === null) {
+        if (stripped === "[" + section + "]") start = i + 1;
+      } else if (stripped.startsWith("[")) {
+        end = i;
+        break;
+      }
+    }
+    if (start === null) {
+      if (lines.length && lines[lines.length - 1].trim() !== "") lines.push("");
+      lines.push("[" + section + "]");
+      start = lines.length;
+      end = lines.length;
+    }
+  } else {
+    start = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim().startsWith("[")) {
+        end = i;
+        break;
+      }
+    }
+  }
+
+  const keyRe = new RegExp("^\\s*" + escapeRe(key) + "\\s*=");
+  for (let i = start; i < end; i++) {
+    if (keyRe.test(lines[i])) {
+      lines[i] = key + " = " + value;
+      return lines.join("\n");
+    }
+  }
+  lines.splice(end, 0, key + " = " + value);
+  return lines.join("\n");
+}
+
+// Read `key` from [section] (or top level). Returns the raw value string
+// (quotes stripped for basic strings) or null.
+function getTomlKey(text, key, section) {
+  if (!text) return null;
+  const lines = text.split(/\r?\n/);
+  let inSection = section === null || section === undefined;
+  const keyRe = new RegExp("^\\s*" + escapeRe(key) + "\\s*=\\s*(.+?)\\s*$");
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped.startsWith("[")) {
+      if (section) inSection = stripped === "[" + section + "]";
+      else inSection = false;
+      continue;
+    }
+    if (!inSection) continue;
+    const m = line.match(keyRe);
+    if (m) {
+      let v = m[1];
+      const q = v.match(/^"(.*)"$/);
+      return q ? q[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\") : v;
+    }
+  }
+  return null;
+}
+
+// Remove [section] and all its [section.*] subsections, header included.
+function removeTomlSection(text, section) {
+  if (!text) return text;
+  const lines = text.split(/\r?\n/);
+  const out = [];
+  let skipping = false;
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped.startsWith("[")) {
+      skipping =
+        stripped === "[" + section + "]" || stripped.startsWith("[" + section + ".");
+    }
+    if (!skipping) out.push(line);
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+// Remove a top-level `key = ...` line.
+function removeTomlKey(text, key) {
+  if (!text) return text;
+  const lines = text.split(/\r?\n/);
+  const keyRe = new RegExp("^\\s*" + escapeRe(key) + "\\s*=");
+  let topLevel = true;
+  const out = [];
+  for (const line of lines) {
+    if (line.trim().startsWith("[")) topLevel = false;
+    if (topLevel && keyRe.test(line)) continue;
+    out.push(line);
+  }
+  return out.join("\n");
+}
+
+module.exports = { tstr, setTomlKey, getTomlKey, removeTomlSection, removeTomlKey };