@anhvupt/tito 0.3.4 → 0.4.0

package/dist/core/hooks.js

@@ -0,0 +1,303 @@
+import { BRANCH_BASES } from "./git-flow.js";
+const ALLOW = { permission: "allow" };
+const BASES = new Set(BRANCH_BASES);
+function isBase(name) {
+    return BASES.has(name);
+}
+function rank(verdict) {
+    return verdict.permission === "deny" ? 2 : verdict.permission === "ask" ? 1 : 0;
+}
+function ask(message) {
+    return { permission: "ask", user_message: message, agent_message: message };
+}
+function deny(message) {
+    return { permission: "deny", user_message: message, agent_message: message };
+}
+function unquote(token) {
+    if (token.length >= 2) {
+        const start = token[0];
+        const end = token[token.length - 1];
+        if ((start === '"' || start === "'") && start === end)
+            return token.slice(1, -1);
+    }
+    return token;
+}
+function tokenize(segment) {
+    const toks = [];
+    let cur = "";
+    let quote = null;
+    const flush = () => {
+        if (cur.length === 0)
+            return;
+        toks.push(unquote(cur));
+        cur = "";
+    };
+    for (const ch of segment) {
+        if (quote !== null) {
+            cur += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            cur += ch;
+            continue;
+        }
+        if (ch === " " || ch === "\t") {
+            flush();
+            continue;
+        }
+        cur += ch;
+    }
+    flush();
+    return toks;
+}
+export function splitCommand(command) {
+    const parts = [];
+    let current = "";
+    let quote = null;
+    const flush = () => {
+        const part = current.trim();
+        if (part.length > 0)
+            parts.push(part);
+        current = "";
+    };
+    for (let i = 0; i < command.length; i += 1) {
+        const ch = command[i];
+        if (quote !== null) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === ";") {
+            flush();
+            continue;
+        }
+        if (ch === "&" && command[i + 1] === "&") {
+            flush();
+            i += 1;
+            continue;
+        }
+        if (ch === "|") {
+            if (command[i + 1] === "|")
+                i += 1;
+            flush();
+            continue;
+        }
+        current += ch;
+    }
+    flush();
+    return parts;
+}
+function skipGitOptions(toks, start) {
+    let i = start;
+    while (i < toks.length) {
+        const t = toks[i];
+        if (t === "-C" || t === "-c" || t === "--git-dir" || t === "--work-tree") {
+            i += 2;
+            continue;
+        }
+        if (t.startsWith("-C") && t.length > 2 ||
+            t.startsWith("--git-dir=") ||
+            t.startsWith("--work-tree=")) {
+            i += 1;
+            continue;
+        }
+        if (t.startsWith("-") && t !== "-" && t !== "--") {
+            i += 1;
+            continue;
+        }
+        break;
+    }
+    return i;
+}
+function refspecDest(spec) {
+    const body = spec.startsWith("+") ? spec.slice(1) : spec;
+    const colon = body.lastIndexOf(":");
+    return colon >= 0 ? body.slice(colon + 1) : body;
+}
+function isForceFlag(token) {
+    if (token === "--force" || token.startsWith("--force-with-lease"))
+        return true;
+    return token.startsWith("-") && !token.startsWith("--") && token.includes("f");
+}
+function pushDests(args) {
+    if (args.length === 0)
+        return [];
+    if (args.length === 1) {
+        const one = args[0];
+        if (one.includes(":") || one.startsWith("+") || isBase(one))
+            return [refspecDest(one)];
+        return [];
+    }
+    return args.slice(1).map(refspecDest);
+}
+function decideGit(toks, currentBranch) {
+    const subAt = skipGitOptions(toks, 1);
+    const sub = toks[subAt];
+    const rest = toks.slice(subAt + 1);
+    if (sub === "push") {
+        let force = false;
+        const args = [];
+        for (const token of rest) {
+            if (token === "--")
+                continue;
+            if (token.startsWith("-")) {
+                if (isForceFlag(token))
+                    force = true;
+                continue;
+            }
+            args.push(token);
+        }
+        if (force)
+            return ask("Force-push requires confirmation.");
+        const dests = pushDests(args);
+        const hit = dests.find((name) => isBase(name));
+        if (hit !== undefined)
+            return ask(`Push to base branch ${hit} requires confirmation.`);
+        if (dests.length === 0 && currentBranch !== undefined && isBase(currentBranch)) {
+            return ask(`Push from base branch ${currentBranch} requires confirmation.`);
+        }
+        return ALLOW;
+    }
+    if (sub === "merge" && currentBranch !== undefined && isBase(currentBranch)) {
+        return ask(`Merge on base branch ${currentBranch} requires confirmation.`);
+    }
+    return ALLOW;
+}
+function isApproveFlag(token) {
+    if (token === "--approve" || token === "-a")
+        return true;
+    return token.startsWith("-") && !token.startsWith("--") && token.includes("a");
+}
+function decideGh(toks, autoMerge) {
+    const pr = toks.indexOf("pr", 1);
+    if (pr < 0)
+        return ALLOW;
+    const rest = toks.slice(pr + 1);
+    if (rest.includes("review") && rest.some(isApproveFlag)) {
+        return deny("Tito never approves a pull request.");
+    }
+    if (rest.includes("merge")) {
+        return autoMerge ? ALLOW : ask("Merging a pull request requires confirmation.");
+    }
+    return ALLOW;
+}
+function decideNpm(toks) {
+    let i = 1;
+    while (i < toks.length && toks[i].startsWith("-"))
+        i += 1;
+    if (toks[i] === "publish")
+        return ask("npm publish requires confirmation.");
+    return ALLOW;
+}
+function decideSegment(segment, currentBranch, autoMerge) {
+    const toks = tokenize(segment);
+    const cmd = toks[0];
+    if (cmd === "git")
+        return decideGit(toks, currentBranch);
+    if (cmd === "gh")
+        return decideGh(toks, autoMerge);
+    if (cmd === "npm")
+        return decideNpm(toks);
+    return ALLOW;
+}
+export function decideShell(command, currentBranch, autoMerge) {
+    const mergeOn = autoMerge === true;
+    let best = ALLOW;
+    for (const segment of splitCommand(command)) {
+        const verdict = decideSegment(segment, currentBranch, mergeOn);
+        if (rank(verdict) > rank(best))
+            best = verdict;
+    }
+    return best;
+}
+const MCP_GUARDED = new Set([
+    "git_push",
+    "git_branch",
+    "merge_pull_request",
+    "create_pull_request_review",
+    "npm_publish",
+]);
+function parseMcpInput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function fieldString(body, key) {
+    const value = body[key];
+    return typeof value === "string" ? value : undefined;
+}
+function pushedRefs(body) {
+    const names = [];
+    for (const key of ["branch", "ref", "dest", "target"]) {
+        const value = fieldString(body, key);
+        if (value !== undefined)
+            names.push(value);
+    }
+    if (Array.isArray(body.refs)) {
+        for (const item of body.refs)
+            if (typeof item === "string")
+                names.push(item);
+    }
+    return names;
+}
+function decideGitPush(body, currentBranch) {
+    let best = ALLOW;
+    const force = body.force === true || body.forceWithLease === true || body.force_with_lease === true;
+    if (force)
+        best = ask("Force-push requires confirmation.");
+    const dests = pushedRefs(body);
+    const hit = dests.find((name) => isBase(name));
+    if (hit !== undefined) {
+        const next = ask(`Push to base branch ${hit} requires confirmation.`);
+        if (rank(next) > rank(best))
+            best = next;
+    }
+    if (dests.length === 0 && isBase(currentBranch)) {
+        const next = ask(`Push from base branch ${currentBranch} requires confirmation.`);
+        if (rank(next) > rank(best))
+            best = next;
+    }
+    return best;
+}
+export function decideMcp(input) {
+    if (!MCP_GUARDED.has(input.toolName))
+        return ALLOW;
+    const body = parseMcpInput(input.toolInput);
+    if (body === null)
+        return ask("Could not read MCP tool input.");
+    if (input.toolName === "npm_publish" || body.command === "npm publish") {
+        return ask("npm publish requires confirmation.");
+    }
+    if (input.toolName === "merge_pull_request") {
+        return input.autoMerge ? ALLOW : ask("Merging a pull request requires confirmation.");
+    }
+    if (input.toolName === "create_pull_request_review") {
+        const event = fieldString(body, "event") ?? fieldString(body, "state");
+        if (event !== undefined && event.toUpperCase() === "APPROVE") {
+            return deny("Tito never approves a pull request.");
+        }
+        return ALLOW;
+    }
+    if (input.toolName === "git_branch") {
+        if (fieldString(body, "action") === "merge" && isBase(input.currentBranch)) {
+            return ask(`Merge on base branch ${input.currentBranch} requires confirmation.`);
+        }
+        return ALLOW;
+    }
+    return decideGitPush(body, input.currentBranch);
+}

package/dist/core/init.js

@@ -30,12 +30,14 @@ export const SCREEN_LANGUAGE_PROMPT = "Screen language (vi, en): ";
 export const TENANCY_PROMPT = "Tenancy (single, multi): ";
 export const SURFACES_PROMPT = "Surfaces (comma-separated ids): ";
 export const AUTO_PULL_REQUEST_PROMPT = "Auto-create a pull request after implementation? [Y/n] ";
+export const AUTO_MERGE_PROMPT = "Auto-merge a slice pull request after checks pass? [y/N] ";
 export const INIT_SETTING_KEYS = [
     "defaultBase",
     "screenLanguage",
     "tenancy",
     "surfaces",
     "autoPullRequest",
+    "autoMerge",
 ];
 async function askOneOf(ask, prompt, allowed) {
     for (;;) {
@@ -75,6 +77,15 @@ async function askAutoPullRequest(ask) {
             return false;
     }
 }
+async function askAutoMerge(ask) {
+    for (;;) {
+        const answer = (await ask(AUTO_MERGE_PROMPT)).trim().toLowerCase();
+        if (answer === "y" || answer === "yes")
+            return true;
+        if (answer === "" || answer === "n" || answer === "no")
+            return false;
+    }
+}
 export async function promptForSettings(ask, keys) {
     const answers = {};
     for (const key of keys) {
@@ -96,7 +107,11 @@ export async function promptForSettings(ask, keys) {
                 answers.surfaces = surfaces;
             continue;
         }
-        answers.autoPullRequest = await askAutoPullRequest(ask);
+        if (key === "autoPullRequest") {
+            answers.autoPullRequest = await askAutoPullRequest(ask);
+            continue;
+        }
+        answers.autoMerge = await askAutoMerge(ask);
     }
     return answers;
 }
@@ -108,6 +123,9 @@ export function titoYamlBody(profile, settings) {
     if (settings.autoPullRequest !== undefined) {
         gitLines.push(`  autoPullRequest: ${settings.autoPullRequest}`);
     }
+    if (settings.autoMerge !== undefined) {
+        gitLines.push(`  autoMerge: ${settings.autoMerge}`);
+    }
     if (gitLines.length > 0)
         lines.push("git:", ...gitLines);
     const productLines = [];
@@ -137,12 +155,35 @@ function exists(root, path) {
 }
 export function shippedSkills() {
     const root = join(dirname(fileURLToPath(import.meta.url)), "../../templates/cursor/skills");
-    return readdirSync(root, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => ({
-        path: `.cursor/skills/${entry.name}/SKILL.md`,
-        body: readFileSync(join(root, entry.name, "SKILL.md"), "utf8"),
-    }));
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        files.push({
+            path: `.cursor/skills/${entry.name}/SKILL.md`,
+            body: readFileSync(join(root, entry.name, "SKILL.md"), "utf8"),
+        });
+        const referencesRoot = join(root, entry.name, "references");
+        let names = [];
+        try {
+            if (!statSync(referencesRoot).isDirectory())
+                continue;
+            names = readdirSync(referencesRoot, { withFileTypes: true })
+                .filter((item) => item.isFile() && item.name.endsWith(".md"))
+                .map((item) => item.name)
+                .sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            files.push({
+                path: `.cursor/skills/${entry.name}/references/${name}`,
+                body: readFileSync(join(referencesRoot, name), "utf8"),
+            });
+        }
+    }
+    return files;
 }
 export function shippedCursorRules() {
     const root = join(dirname(fileURLToPath(import.meta.url)), "../../templates/cursor/rules");
@@ -155,6 +196,73 @@ export function shippedCursorRules() {
         body: readFileSync(join(root, name), "utf8"),
     }));
 }
+export const CURSOR_HOOKS_PATH = ".cursor/hooks.json";
+export function shippedCursorHooks() {
+    return readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../../templates/cursor/hooks.json"), "utf8");
+}
+function hookCommandHas(value, needle) {
+    if (Array.isArray(value))
+        return value.some((item) => hookCommandHas(item, needle));
+    if (value === null || typeof value !== "object")
+        return false;
+    const record = value;
+    return ((typeof record.command === "string" && record.command.includes(needle)) ||
+        Object.values(record).some((item) => hookCommandHas(item, needle)));
+}
+function shippedHookEntries() {
+    const shipped = JSON.parse(shippedCursorHooks());
+    const rows = [];
+    for (const [event, list] of Object.entries(shipped.hooks ?? {})) {
+        if (!Array.isArray(list))
+            continue;
+        for (const entry of list) {
+            const command = entry !== null && typeof entry === "object"
+                ? entry.command
+                : undefined;
+            if (typeof command !== "string")
+                continue;
+            const at = command.indexOf("tito hook ");
+            if (at < 0)
+                continue;
+            rows.push({ event, entry, needle: command.slice(at) });
+        }
+    }
+    return rows;
+}
+export function planCursorHooks(root) {
+    if (!exists(root, CURSOR_HOOKS_PATH)) {
+        return { path: CURSOR_HOOKS_PATH, action: "create", body: shippedCursorHooks() };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(join(root, CURSOR_HOOKS_PATH), "utf8"));
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error();
+        const body = parsed;
+        const hooks = body.hooks !== null && typeof body.hooks === "object" && !Array.isArray(body.hooks)
+            ? { ...body.hooks }
+            : {};
+        let changed = false;
+        for (const { event, entry, needle } of shippedHookEntries()) {
+            if (hookCommandHas(body, needle))
+                continue;
+            const current = hooks[event];
+            const list = Array.isArray(current) ? [...current] : [];
+            list.push(entry);
+            hooks[event] = list;
+            changed = true;
+        }
+        if (!changed)
+            return { path: CURSOR_HOOKS_PATH, action: "keep" };
+        return {
+            path: CURSOR_HOOKS_PATH,
+            action: "append",
+            body: `${JSON.stringify({ ...body, hooks }, null, 2)}\n`,
+        };
+    }
+    catch {
+        return { path: CURSOR_HOOKS_PATH, action: "conflict" };
+    }
+}
 function agentsBootstrap(report) {
     if (report.agentsMd === "absent") {
         return { path: "AGENTS.md", action: "create", body: titoBootstrapBlock() };
@@ -201,7 +309,7 @@ export function planInitialization(report, profile, settings) {
     return {
         root: adoption.root,
         profile: adoption.profile,
-        files: [...files, ...agents, ...skills, pullRequest, ...rules],
+        files: [...files, ...agents, ...skills, pullRequest, ...rules, planCursorHooks(report.root)],
     };
 }
 export function formatInitialization(plan) {
@@ -224,6 +332,10 @@ export function applyInitialization(plan) {
         for (const file of plan.files) {
             if (file.action === "append") {
                 const absolute = join(plan.root, file.path);
+                if (file.path === CURSOR_HOOKS_PATH) {
+                    writeFileSync(absolute, file.body, "utf8");
+                    continue;
+                }
                 const current = readFileSync(absolute, "utf8");
                 const separator = current.endsWith("\n") ? "\n" : "\n\n";
                 writeFileSync(absolute, `${current}${separator}${file.body}`, "utf8");

package/dist/core/specialists.js

@@ -10,6 +10,8 @@ export const SPECIALIST_IDS = [
     "security-reviewer",
     "tech-docs-writer",
     "user-docs-writer",
+    "cleaner",
+    "startup",
 ];
 export const WRITER_SPECIALIST_IDS = [
     "backend-engineer",
@@ -17,6 +19,8 @@ export const WRITER_SPECIALIST_IDS = [
     "devops-engineer",
     "tech-docs-writer",
     "user-docs-writer",
+    "cleaner",
+    "startup",
 ];
 export const READ_ONLY_SPECIALIST_IDS = [
     "explorer",
@@ -28,16 +32,18 @@ export const READ_ONLY_SPECIALIST_IDS = [
 ];
 export const SPECIALIST_MODEL_ROLES = Object.freeze({
     explorer: "explorer",
-    "product-analyst": "planner",
+    "product-analyst": "advisor",
     architect: "planner",
     "backend-engineer": "implementer",
     "frontend-engineer": "implementer",
     "devops-engineer": "implementer",
-    "erp-specialist": "planner",
+    "erp-specialist": "advisor",
     "qa-reviewer": "reviewer",
     "security-reviewer": "planner",
     "tech-docs-writer": "finisher",
     "user-docs-writer": "finisher",
+    cleaner: "finisher",
+    startup: "finisher",
 });
 const phase = Object.freeze({
     discovery: ["discovery"],
@@ -178,6 +184,24 @@ export const SPECIALISTS = Object.freeze({
         modes: [specialistMode("update", "write-files", phase.implementation)],
         stopCondition: "Apply the plan's Docs impact (update named docs, or record a waiver) before a pull request. The module-end pass still covers larger docs. Stop after that docs work matches the plan.",
     }),
+    cleaner: manifest("cleaner", {
+        tier: "Scout",
+        role: "Cleanup specialist",
+        triggers: ["leftover files", "unused local artifacts", "dead code cleanup"],
+        knowledge: [knowledge("cleanup-safety", "always")],
+        modes: [specialistMode("implement", "write-files", phase.implementation)],
+        stopCondition: "Stop after the approved cleanup slice is verified. Do not delete remote branches, production data, secrets, or the main checkout. Do not rebase.",
+    }),
+    startup: manifest("startup", {
+        tier: "Scout",
+        role: "Local startup",
+        triggers: ["local infra", "start apps", "pending migrations"],
+        knowledge: [knowledge("local-startup", "task")],
+        modes: [
+            specialistMode("start", "write-infrastructure", phase.implementation, ["human-approval"]),
+        ],
+        stopCondition: "Stop after missing local processes are started. Ask before applying pending migrations. Local only. Do not migrate remote or production databases. Do not docker compose down -v. Do not drop data.",
+    }),
 });
 export class DelegationError extends Error {
     code;

package/dist/core/upgrade.js

@@ -4,7 +4,7 @@ import { parseDocument } from "yaml";
 import { compiledCursorAgents } from "./agents.js";
 import { ConfigValidationError, DEFAULT_MODELS, MODEL_ROLES, parseConfig, } from "./config.js";
 import { PULL_REQUEST_TEMPLATE_PATH, pullRequestTemplate } from "./git-flow.js";
-import { shippedCursorRules, shippedSkills, titoYamlBody, } from "./init.js";
+import { planCursorHooks, shippedCursorRules, shippedSkills, titoYamlBody, } from "./init.js";
 import { TITO_BOOTSTRAP_END, TITO_BOOTSTRAP_START, titoBootstrapBlock, } from "./plan.js";
 function readIfFile(root, path) {
     try {
@@ -59,6 +59,10 @@ export function planUpgrade(root, ownedFiles) {
             ? { path: "AGENTS.md", action: "keep" }
             : { path: "AGENTS.md", action: "replace", body: next });
     }
+    const hooks = planCursorHooks(root);
+    files.push(hooks.action === "create" || hooks.action === "append"
+        ? { path: hooks.path, action: hooks.action, body: hooks.body }
+        : { path: hooks.path, action: hooks.action });
     return files;
 }
 function readConfigText(text) {
@@ -114,6 +118,8 @@ export function missingSettings(config) {
         missing.push("surfaces");
     if (config.git?.autoPullRequest === undefined)
         missing.push("autoPullRequest");
+    if (config.git?.autoMerge === undefined)
+        missing.push("autoMerge");
     return missing;
 }
 export function mergeSettings(yamlText, answers) {
@@ -134,6 +140,13 @@ export function mergeSettings(yamlText, answers) {
         settings.autoPullRequest = answers.autoPullRequest;
         changed = true;
     }
+    const existingMerge = config.git?.autoMerge;
+    if (existingMerge !== undefined)
+        settings.autoMerge = existingMerge;
+    else if (answers.autoMerge !== undefined) {
+        settings.autoMerge = answers.autoMerge;
+        changed = true;
+    }
     const existingLanguage = config.product?.screenLanguage;
     if (existingLanguage !== undefined)
         settings.screenLanguage = existingLanguage;

package/dist/core/usage-eval.js

@@ -0,0 +1,81 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export const LOCKED_MODEL_ID = "composer-2.5";
+export const USAGE_BASELINE_PATH = "evals/usage-baseline.json";
+export function overBudget(actual, baseline) {
+    return actual > baseline * 1.25;
+}
+function copyUsage(usage) {
+    const copied = {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadTokens: usage.cacheReadTokens,
+        cacheWriteTokens: usage.cacheWriteTokens,
+        totalTokens: usage.totalTokens,
+    };
+    return usage.reasoningTokens === undefined ? copied : { ...copied, reasoningTokens: usage.reasoningTokens };
+}
+export async function buildUsageRecord(input) {
+    if (input.result.usage === undefined)
+        return { ok: false, failure: "missing-usage" };
+    let cost = null;
+    try {
+        cost = (await input.getUsage()).cost ?? null;
+    }
+    catch {
+        cost = null;
+    }
+    return {
+        ok: true,
+        record: {
+            scenario: input.scenario,
+            model: input.model,
+            usage: copyUsage(input.result.usage),
+            cost,
+            requestId: input.result.requestId,
+            status: input.result.status,
+        },
+    };
+}
+export function persistOutcome(root, outcome) {
+    if (!outcome.ok)
+        return;
+    const dir = join(root, ".tito", "evals", "usage");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${outcome.record.scenario}.json`), `${JSON.stringify(outcome.record, null, 2)}\n`);
+}
+export function baselineFromRecords(records) {
+    const scenarios = {};
+    for (const record of records)
+        scenarios[record.scenario] = { totalTokens: record.usage.totalTokens };
+    return { model: LOCKED_MODEL_ID, scenarios };
+}
+export function writeBaseline(root, baseline) {
+    mkdirSync(join(root, "evals"), { recursive: true });
+    writeFileSync(join(root, USAGE_BASELINE_PATH), `${JSON.stringify(baseline, null, 2)}\n`);
+}
+export function thresholdFailures(records, baseline) {
+    const failures = [];
+    for (const record of records) {
+        const expected = baseline.scenarios[record.scenario]?.totalTokens;
+        if (expected === undefined)
+            failures.push(`${record.scenario}: missing-baseline`);
+        else if (overBudget(record.usage.totalTokens, expected))
+            failures.push(`${record.scenario}: over-budget`);
+    }
+    return failures;
+}
+export function evalExitCode(input) {
+    if (input.missingUsage)
+        return 1;
+    if (input.record)
+        return 0;
+    return input.overBudget ? 1 : 0;
+}
+export function nodeVersionTooOld(version) {
+    const [major, minor] = version.split(".").map((part) => Number(part));
+    return (major ?? 0) < 22 || ((major ?? 0) === 22 && (minor ?? 0) < 13);
+}
+export function missingCursorApiKey(apiKey) {
+    return apiKey === undefined || apiKey.trim() === "";
+}