@riocrypto/common-server 1.0.2935 → 1.0.2937

package/build/bot/k8s-client.js

@@ -0,0 +1,151 @@
+"use strict";
+// Minimal, GET-only client for the in-cluster Kubernetes API.
+//
+// Deliberately not the official @kubernetes/client-node package. That
+// library is ESM only, pulls in websockets, tar, socks and OIDC, and exposes
+// exec/attach/delete on the same object we would hand to the tool layer. We
+// need four GET endpoints. Fewer moving parts, no write surface in the code
+// at all, and the RBAC Role bound to the pod is the second lock.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.K8sClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const SA_DIR = "/var/run/secrets/kubernetes.io/serviceaccount";
+const minutesSince = (iso) => {
+    if (!iso)
+        return -1;
+    const t = new Date(iso).getTime();
+    return Number.isNaN(t) ? -1 : Math.floor((Date.now() - t) / 60000);
+};
+class K8sClient {
+    constructor(baseURL, ca, timeoutMs) {
+        this.http = axios_1.default.create({
+            baseURL,
+            timeout: timeoutMs,
+            httpsAgent: ca ? new https_1.default.Agent({ ca }) : undefined,
+            // Only GET is ever issued. Kept explicit so a future refactor cannot
+            // silently add a body-carrying method through this instance.
+            maxRedirects: 0,
+            validateStatus: (s) => s >= 200 && s < 300,
+        });
+    }
+    static fromInCluster(timeoutMs) {
+        const host = process.env.KUBERNETES_SERVICE_HOST;
+        const port = process.env.KUBERNETES_SERVICE_PORT || "443";
+        if (!host || !fs_1.default.existsSync(`${SA_DIR}/token`)) {
+            return null;
+        }
+        const ca = fs_1.default.existsSync(`${SA_DIR}/ca.crt`)
+            ? fs_1.default.readFileSync(`${SA_DIR}/ca.crt`)
+            : undefined;
+        return new K8sClient(`https://${host}:${port}`, ca, timeoutMs);
+    }
+    // Projected tokens rotate, so read on every call rather than caching.
+    headers() {
+        const token = fs_1.default.readFileSync(`${SA_DIR}/token`, "utf8").trim();
+        return { Authorization: `Bearer ${token}`, Accept: "application/json" };
+    }
+    get(path, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.http.get(path, { params, headers: this.headers() });
+            return res.data;
+        });
+    }
+    listPods(namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.get(`/api/v1/namespaces/${namespace}/pods`, {
+                limit: 500,
+            });
+            return (data.items || []).map((pod) => {
+                var _a, _b, _c, _d, _e, _f, _g;
+                const statuses = ((_a = pod.status) === null || _a === void 0 ? void 0 : _a.containerStatuses) || [];
+                const readyCount = statuses.filter((s) => s.ready).length;
+                const restarts = statuses.reduce((n, s) => n + (s.restartCount || 0), 0);
+                const lastState = statuses
+                    .map((s) => {
+                    var _a;
+                    const term = (_a = s.lastState) === null || _a === void 0 ? void 0 : _a.terminated;
+                    if (!term)
+                        return null;
+                    return `${s.name}: ${term.reason || "terminated"} exit=${term.exitCode} at ${term.finishedAt}`;
+                })
+                    .filter(Boolean)
+                    .join("; ");
+                return Object.assign({ name: (_b = pod.metadata) === null || _b === void 0 ? void 0 : _b.name, phase: (_c = pod.status) === null || _c === void 0 ? void 0 : _c.phase, ready: `${readyCount}/${(((_d = pod.spec) === null || _d === void 0 ? void 0 : _d.containers) || []).length}`, restarts, ageMinutes: minutesSince((_e = pod.metadata) === null || _e === void 0 ? void 0 : _e.creationTimestamp), containers: (((_f = pod.spec) === null || _f === void 0 ? void 0 : _f.containers) || []).map((c) => c.name), node: (_g = pod.spec) === null || _g === void 0 ? void 0 : _g.nodeName }, (lastState ? { lastState } : {}));
+            });
+        });
+    }
+    getPodLog(namespace, pod, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                tailLines: options.tailLines,
+                sinceSeconds: options.sinceSeconds,
+                timestamps: true,
+            };
+            if (options.container)
+                params.container = options.container;
+            if (options.previous)
+                params.previous = true;
+            const res = yield this.http.get(`/api/v1/namespaces/${namespace}/pods/${pod}/log`, {
+                params,
+                headers: Object.assign(Object.assign({}, this.headers()), { Accept: "text/plain" }),
+                responseType: "text",
+                transformResponse: (d) => d,
+            });
+            return typeof res.data === "string" ? res.data : String(res.data);
+        });
+    }
+    listDeployments(namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.get(`/apis/apps/v1/namespaces/${namespace}/deployments`, { limit: 500 });
+            return (data.items || []).map((d) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+                return ({
+                    name: (_a = d.metadata) === null || _a === void 0 ? void 0 : _a.name,
+                    desired: (_c = (_b = d.spec) === null || _b === void 0 ? void 0 : _b.replicas) !== null && _c !== void 0 ? _c : 0,
+                    ready: (_e = (_d = d.status) === null || _d === void 0 ? void 0 : _d.readyReplicas) !== null && _e !== void 0 ? _e : 0,
+                    available: (_g = (_f = d.status) === null || _f === void 0 ? void 0 : _f.availableReplicas) !== null && _g !== void 0 ? _g : 0,
+                    updated: (_j = (_h = d.status) === null || _h === void 0 ? void 0 : _h.updatedReplicas) !== null && _j !== void 0 ? _j : 0,
+                    images: (((_m = (_l = (_k = d.spec) === null || _k === void 0 ? void 0 : _k.template) === null || _l === void 0 ? void 0 : _l.spec) === null || _m === void 0 ? void 0 : _m.containers) || []).map((c) => c.image),
+                    conditions: (((_o = d.status) === null || _o === void 0 ? void 0 : _o.conditions) || []).map((c) => `${c.type}=${c.status}${c.reason ? ` (${c.reason})` : ""}`),
+                });
+            });
+        });
+    }
+    listEvents(namespace, involvedObjectName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = { limit: 500 };
+            if (involvedObjectName) {
+                params.fieldSelector = `involvedObject.name=${involvedObjectName}`;
+            }
+            const data = yield this.get(`/api/v1/namespaces/${namespace}/events`, params);
+            return (data.items || [])
+                .map((e) => {
+                var _a, _b, _c;
+                return ({
+                    lastSeen: e.lastTimestamp || e.eventTime || ((_a = e.metadata) === null || _a === void 0 ? void 0 : _a.creationTimestamp) || "",
+                    type: e.type,
+                    reason: e.reason,
+                    object: `${(_b = e.involvedObject) === null || _b === void 0 ? void 0 : _b.kind}/${(_c = e.involvedObject) === null || _c === void 0 ? void 0 : _c.name}`,
+                    count: e.count || 1,
+                    message: e.message || "",
+                });
+            })
+                .sort((a, b) => (a.lastSeen < b.lastSeen ? 1 : -1));
+        });
+    }
+}
+exports.K8sClient = K8sClient;

package/build/bot/redactor.d.ts

@@ -0,0 +1,11 @@
+export type RedactionCategory = "privateKey" | "urlCredentials" | "cookieHeader" | "credentialField" | "jwt" | "authHeader" | "apiKey" | "curp" | "rfc" | "clabe" | "phone" | "card" | "email";
+export interface RedactionResult {
+    text: string;
+    counts: Partial<Record<RedactionCategory, number>>;
+    total: number;
+}
+export declare function redact(input: string): RedactionResult;
+export declare const CREDENTIAL_CATEGORIES: RedactionCategory[];
+export declare function redactCredentials(input: string): RedactionResult;
+export declare function countCredentialRedactions(counts: Partial<Record<RedactionCategory, number>>): number;
+export declare function summarizeRedactions(counts: Partial<Record<RedactionCategory, number>>): string;

package/build/bot/redactor.js

@@ -0,0 +1,186 @@
+"use strict";
+// Deterministic scrubber applied to every tool result BEFORE it is placed in
+// the model context, and again to the model's final answer before it is
+// returned to the engineer. Nothing here depends on the model. If a value is
+// caught by a rule it never reaches Anthropic and never reaches the browser.
+//
+// Rule order matters. Structured secrets (key blocks, URLs with credentials,
+// named credential fields) run first so that a later, looser pattern does
+// not chew up part of a match and leave a fragment behind.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeRedactions = exports.countCredentialRedactions = exports.redactCredentials = exports.CREDENTIAL_CATEGORIES = exports.redact = void 0;
+const REDACTED = "[REDACTED]";
+// Key names whose values are always secrets. Matched as the tail of the key
+// so `accessToken`, `x-api-key`, `db_password` and `Authorization` all hit,
+// while identifiers like `authId` or `tokenId` do not.
+const CREDENTIAL_KEY = "(?:[A-Za-z0-9_.\\-]*(?:password|passwd|secret|token|api[_-]?key|apikey|authorization|cookie|private[_-]?key|mnemonic|seed[_-]?phrase|cvv|cvc|access[_-]?key|signing[_-]?key|credentials?)|seed|otp|pin|pwd|pass)";
+const PHONE_KEY = "(?:phone|phone[_-]?number|tel|telefono|teléfono|celular|mobile|whatsapp)";
+const keepLast4 = (digits, label) => `${label} ****${digits.slice(-4)}`;
+const luhnValid = (digits) => {
+    let sum = 0;
+    let alternate = false;
+    for (let i = digits.length - 1; i >= 0; i--) {
+        let n = digits.charCodeAt(i) - 48;
+        if (alternate) {
+            n *= 2;
+            if (n > 9)
+                n -= 9;
+        }
+        sum += n;
+        alternate = !alternate;
+    }
+    return sum % 10 === 0;
+};
+const RULES = [
+    {
+        category: "privateKey",
+        pattern: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+        replace: () => "[REDACTED_PRIVATE_KEY]",
+    },
+    {
+        category: "urlCredentials",
+        pattern: /(\b[a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^\s/:@"']+):([^\s/@"']+)@/g,
+        replace: (_m, scheme, user) => `${scheme}${user}:${REDACTED}@`,
+    },
+    {
+        category: "cookieHeader",
+        pattern: /\b(cookie|set-cookie)(["']?\s*[:=]\s*)(?:"[^"\n]*"|'[^'\n]*'|[^\n"']+)/gi,
+        replace: (_m, header, sep) => `${header}${sep}${REDACTED}`,
+    },
+    {
+        // JSON style: "password": "hunter2"  |  "token": 'abc'  |  "otp": 123456
+        category: "credentialField",
+        pattern: new RegExp(`("${CREDENTIAL_KEY}"\\s*:\\s*)("(?:[^"\\\\]|\\\\.)*"|'[^']*'|[^,}\\]\\s]+)`, "gi"),
+        replace: (_m, prefix) => `${prefix}"${REDACTED}"`,
+    },
+    {
+        // Text style: password=hunter2  |  Authorization: Bearer xyz  |  token: abc
+        category: "credentialField",
+        pattern: new RegExp(`\\b(${CREDENTIAL_KEY})(\\s*[=:]\\s*)((?:Bearer|Basic)\\s+[^\\s,;&"']+|"[^"\\n]*"|'[^'\\n]*'|[^\\s,;&"']+)`, "gi"),
+        replace: (_m, key, sep) => `${key}${sep}${REDACTED}`,
+    },
+    {
+        category: "jwt",
+        pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+        replace: () => "[REDACTED_JWT]",
+    },
+    {
+        category: "authHeader",
+        pattern: /\b(Bearer|Basic)\s+[A-Za-z0-9\-._~+/]{16,}=*/g,
+        replace: (_m, scheme) => `${scheme} ${REDACTED}`,
+    },
+    {
+        category: "apiKey",
+        pattern: /\b(?:sk-ant-[A-Za-z0-9_-]{20,}|sk-[A-Za-z0-9_-]{20,}|sk_live_[A-Za-z0-9]{10,}|rk_live_[A-Za-z0-9]{10,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{35}|gh[pousr]_[A-Za-z0-9]{36,}|xox[abprs]-[A-Za-z0-9-]{10,}|glpat-[A-Za-z0-9_-]{20,})\b/g,
+        replace: () => "[REDACTED_API_KEY]",
+    },
+    {
+        category: "curp",
+        pattern: /\b[A-Z]{4}\d{6}[HM][A-Z]{2}[B-DF-HJ-NP-TV-Z]{3}[A-Z0-9]\d\b/g,
+        replace: () => "[REDACTED_CURP]",
+    },
+    {
+        // Field-aware only. A bare RFC shape (3-4 letters, 6 digits, 3 alnum)
+        // collides with payment tracking keys, which are exactly what this bot
+        // is used to search for.
+        category: "rfc",
+        pattern: /("?\b(?:rfc|tax[_-]?id)"?\s*[:=]\s*"?)([A-ZÑ&]{3,4}\d{6}[A-Z0-9]{3})\b/gi,
+        replace: (_m, prefix) => `${prefix}[REDACTED_RFC]`,
+    },
+    {
+        category: "clabe",
+        pattern: /\b\d{18}\b/g,
+        replace: (m) => keepLast4(m, "CLABE"),
+    },
+    {
+        // Field-aware phone masking. A bare 10 digit run is far more likely to be
+        // a unix timestamp than a phone number, so we only mask when the number
+        // is labelled or carries an international prefix.
+        category: "phone",
+        pattern: new RegExp(`("?\\b${PHONE_KEY}"?\\s*[:=]\\s*"?)(\\+?[\\d][\\d\\s\\-()]{8,18}\\d)`, "gi"),
+        replace: (_m, prefix, number) => `${prefix}${keepLast4(number.replace(/\D/g, ""), "PHONE")}`,
+    },
+    {
+        category: "phone",
+        pattern: /\+\d{1,3}[\s-]?\(?\d{2,4}\)?[\s-]?\d{3,4}[\s-]?\d{4}\b/g,
+        replace: (m) => keepLast4(m.replace(/\D/g, ""), "PHONE"),
+    },
+    {
+        category: "card",
+        pattern: /\b(?:\d[ -]?){12,18}\d\b/g,
+        replace: (m) => {
+            const digits = m.replace(/\D/g, "");
+            if (digits.length < 13 || digits.length > 19 || !luhnValid(digits)) {
+                return m;
+            }
+            // 13 digit runs starting with 1 are millisecond timestamps, which
+            // pass Luhn one time in ten. Real 13 digit cards are old Visa (4...).
+            if (digits.length === 13 && digits.startsWith("1")) {
+                return m;
+            }
+            return keepLast4(digits, "CARD");
+        },
+    },
+    {
+        category: "email",
+        pattern: /\b([A-Za-z0-9._%+-])[A-Za-z0-9._%+-]*@([A-Za-z0-9.-]+\.[A-Za-z]{2,})\b/g,
+        replace: (_m, first, domain) => `${first}***@${domain}`,
+    },
+];
+const applyRules = (input, rules) => {
+    const counts = {};
+    let text = input;
+    let total = 0;
+    for (const rule of rules) {
+        let hits = 0;
+        text = text.replace(rule.pattern, (match, ...rest) => {
+            // String.replace passes (match, ...groups, offset, string). Drop the
+            // trailing offset and source so the rule only sees its groups.
+            const groups = rest.slice(0, -2);
+            const replaced = rule.replace(match, ...groups);
+            if (replaced !== match)
+                hits++;
+            return replaced;
+        });
+        if (hits > 0) {
+            counts[rule.category] = (counts[rule.category] || 0) + hits;
+            total += hits;
+        }
+    }
+    return { text, counts, total };
+};
+function redact(input) {
+    return applyRules(input, RULES);
+}
+exports.redact = redact;
+// Categories that mean "a secret was present". PII categories (email, phone,
+// CLABE, card, CURP, RFC) are masked for hygiene but are normal debugging
+// data; only credential hits are treated as security signals.
+exports.CREDENTIAL_CATEGORIES = [
+    "privateKey",
+    "urlCredentials",
+    "cookieHeader",
+    "credentialField",
+    "jwt",
+    "authHeader",
+    "apiKey",
+];
+// For the engineer's own question. Emails, ids, CLABEs and phone numbers in
+// a question are what the engineer is asking about and must survive, so
+// only credential material is scrubbed before the question is stored or
+// sent to the model.
+function redactCredentials(input) {
+    return applyRules(input, RULES.filter((rule) => exports.CREDENTIAL_CATEGORIES.includes(rule.category)));
+}
+exports.redactCredentials = redactCredentials;
+function countCredentialRedactions(counts) {
+    return exports.CREDENTIAL_CATEGORIES.reduce((n, c) => n + (counts[c] || 0), 0);
+}
+exports.countCredentialRedactions = countCredentialRedactions;
+function summarizeRedactions(counts) {
+    const parts = Object.entries(counts)
+        .filter(([, n]) => (n || 0) > 0)
+        .map(([category, n]) => `${category}: ${n}`);
+    return parts.length > 0 ? parts.join(", ") : "none";
+}
+exports.summarizeRedactions = summarizeRedactions;

package/build/bot/slack-notifier.d.ts

@@ -0,0 +1,15 @@
+export interface SlackNotifierOptions {
+    channelId: string;
+    prefix: string;
+    localToken?: string;
+    log?: (message: string) => void;
+}
+export declare class SlackNotifier {
+    private readonly options;
+    private queue;
+    private readonly log;
+    constructor(options: SlackNotifierOptions);
+    get enabled(): boolean;
+    notify(text: string): void;
+    private postWithLocalToken;
+}

package/build/bot/slack-notifier.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackNotifier = void 0;
+const axios_1 = __importDefault(require("axios"));
+const slack_client_1 = require("../clients/slack-client");
+// Posts are chained so they reach Slack in the order they were raised (the
+// signal that caused a lockout before the lockout itself). Callers never
+// wait on the chain. An empty channel id disables sending entirely.
+class SlackNotifier {
+    constructor(options) {
+        this.options = options;
+        this.queue = Promise.resolve();
+        this.log = options.log || (() => undefined);
+    }
+    get enabled() {
+        return this.options.channelId.length > 0;
+    }
+    notify(text) {
+        if (!this.enabled)
+            return;
+        const prefixed = `${this.options.prefix} ${text}`;
+        this.queue = this.queue.then(() => (this.options.localToken
+            ? this.postWithLocalToken(prefixed)
+            : slack_client_1.slackClient.sendMessage(prefixed, this.options.channelId))
+            .then(() => this.log(`Slack notify sent to ${this.options.channelId}`))
+            .catch((error) => this.log(`Slack notify failed: ${(error === null || error === void 0 ? void 0 : error.message) || error}`)));
+    }
+    postWithLocalToken(text) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield axios_1.default.post("https://slack.com/api/chat.postMessage", { channel: this.options.channelId, text }, {
+                headers: { Authorization: `Bearer ${this.options.localToken}` },
+                timeout: 10000,
+                maxRedirects: 0,
+            });
+            if (!((_a = response.data) === null || _a === void 0 ? void 0 : _a.ok)) {
+                throw new Error(((_b = response.data) === null || _b === void 0 ? void 0 : _b.error) || "unknown Slack error");
+            }
+        });
+    }
+}
+exports.SlackNotifier = SlackNotifier;

package/build/bot/tool.d.ts

@@ -0,0 +1,26 @@
+export declare class ToolInputError extends Error {
+}
+export declare class ToolAccessError extends ToolInputError {
+}
+export interface ToolInputSchema {
+    type: "object";
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+export interface ToolExecution {
+    summary: string;
+    output: string;
+}
+export interface BotTool {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+    isSourceCode?: boolean;
+    execute(input: Record<string, unknown>): Promise<ToolExecution>;
+}
+export declare const requireString: (input: Record<string, unknown>, key: string, maxLength: number) => string;
+export declare const optionalString: (input: Record<string, unknown>, key: string, maxLength: number) => string | undefined;
+export declare const clampInt: (input: Record<string, unknown>, key: string, fallback: number, min: number, max: number) => number;
+export declare const optionalBool: (input: Record<string, unknown>, key: string) => boolean;
+export declare const requireK8sName: (input: Record<string, unknown>, key: string) => string;

package/build/bot/tool.js

@@ -0,0 +1,60 @@
+"use strict";
+// Shared primitives for model-facing tools. Every tool built on these is a
+// read; the helpers exist so model input is validated the same way in every
+// bot before it touches GCP, Kubernetes, git or Mongo.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireK8sName = exports.optionalBool = exports.clampInt = exports.optionalString = exports.requireString = exports.ToolAccessError = exports.ToolInputError = void 0;
+// Raised when the model passes something a tool refuses to act on (bad type,
+// out of range, namespace not allowed). Sent back to the model as an
+// is_error tool_result so it can correct itself.
+class ToolInputError extends Error {
+}
+exports.ToolInputError = ToolInputError;
+// A ToolInputError that means "not allowed" rather than "malformed": a repo
+// outside the allowlist, a denied path, a namespace out of scope. Bots count
+// these as security signals; ordinary input mistakes are not.
+class ToolAccessError extends ToolInputError {
+}
+exports.ToolAccessError = ToolAccessError;
+const requireString = (input, key, maxLength) => {
+    const value = input[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new ToolInputError(`"${key}" must be a non-empty string`);
+    }
+    if (value.length > maxLength) {
+        throw new ToolInputError(`"${key}" exceeds ${maxLength} characters`);
+    }
+    return value.trim();
+};
+exports.requireString = requireString;
+const optionalString = (input, key, maxLength) => {
+    if (input[key] === undefined || input[key] === null || input[key] === "") {
+        return undefined;
+    }
+    return (0, exports.requireString)(input, key, maxLength);
+};
+exports.optionalString = optionalString;
+const clampInt = (input, key, fallback, min, max) => {
+    const raw = input[key];
+    if (raw === undefined || raw === null)
+        return fallback;
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new ToolInputError(`"${key}" must be a number`);
+    }
+    return Math.min(max, Math.max(min, Math.floor(n)));
+};
+exports.clampInt = clampInt;
+const optionalBool = (input, key) => input[key] === true || input[key] === "true";
+exports.optionalBool = optionalBool;
+// Kubernetes names: lowercase DNS labels. Anything else is refused before it
+// is interpolated into an API path.
+const K8S_NAME = /^[a-z0-9]([-a-z0-9.]{0,251}[a-z0-9])?$/;
+const requireK8sName = (input, key) => {
+    const value = (0, exports.requireString)(input, key, 253);
+    if (!K8S_NAME.test(value)) {
+        throw new ToolInputError(`"${key}" is not a valid Kubernetes name`);
+    }
+    return value;
+};
+exports.requireK8sName = requireK8sName;

package/build/index.d.ts

@@ -138,6 +138,20 @@ export * from "./models/internal-support-chat-message";
 export * from "./models/internal-support-audit-event";
 export * from "./models/internal-support-case";
 export * from "./models/internal-support-security";
+export * from "./models/security-finding";
+export * from "./models/security-sweep-run";
+export * from "./models/security-baseline";
+export * from "./models/security-known-pattern";
+export * from "./models/security-bot-controls";
+export * from "./models/security-bot-audit-event";
+export * from "./bot/redactor";
+export * from "./bot/injection-markers";
+export * from "./bot/tool";
+export * from "./bot/gcp-logging-client";
+export * from "./bot/k8s-client";
+export * from "./bot/github-app-auth";
+export * from "./bot/git-repo-cache";
+export * from "./bot/slack-notifier";
 export * from "./models/compliance-bot-rule";
 export * from "./models/compliance-bot-rule-result";
 export * from "./models/compliance-rule-set";

package/build/index.js

@@ -154,6 +154,20 @@ __exportStar(require("./models/internal-support-chat-message"), exports);
 __exportStar(require("./models/internal-support-audit-event"), exports);
 __exportStar(require("./models/internal-support-case"), exports);
 __exportStar(require("./models/internal-support-security"), exports);
+__exportStar(require("./models/security-finding"), exports);
+__exportStar(require("./models/security-sweep-run"), exports);
+__exportStar(require("./models/security-baseline"), exports);
+__exportStar(require("./models/security-known-pattern"), exports);
+__exportStar(require("./models/security-bot-controls"), exports);
+__exportStar(require("./models/security-bot-audit-event"), exports);
+__exportStar(require("./bot/redactor"), exports);
+__exportStar(require("./bot/injection-markers"), exports);
+__exportStar(require("./bot/tool"), exports);
+__exportStar(require("./bot/gcp-logging-client"), exports);
+__exportStar(require("./bot/k8s-client"), exports);
+__exportStar(require("./bot/github-app-auth"), exports);
+__exportStar(require("./bot/git-repo-cache"), exports);
+__exportStar(require("./bot/slack-notifier"), exports);
 __exportStar(require("./models/compliance-bot-rule"), exports);
 __exportStar(require("./models/compliance-bot-rule-result"), exports);
 __exportStar(require("./models/compliance-rule-set"), exports);

package/build/models/security-baseline.d.ts

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+export interface SecurityBaselineDoc extends mongoose.Document {
+    entityKind: string;
+    entityId: string;
+    metric: string;
+    bucket: string;
+    value: number;
+    samples: number;
+    updatedAt: Date;
+}
+export type SecurityBaselineModel = mongoose.Model<SecurityBaselineDoc>;
+declare const buildSecurityBaseline: (mongoose: typeof mongoose) => SecurityBaselineModel;
+export { buildSecurityBaseline };

package/build/models/security-baseline.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSecurityBaseline = void 0;
+const buildSecurityBaseline = (mongoose) => {
+    if (mongoose.models.SecurityBaseline) {
+        return mongoose.model("SecurityBaseline");
+    }
+    const schema = new mongoose.Schema({
+        entityKind: { type: String, required: true },
+        entityId: { type: String, required: true },
+        metric: { type: String, required: true },
+        bucket: { type: String, required: true },
+        value: { type: Number, default: 0 },
+        samples: { type: Number, default: 0 },
+    }, {
+        timestamps: { createdAt: false, updatedAt: true },
+        collection: "securityBaselines",
+    });
+    schema.index({ entityKind: 1, entityId: 1, metric: 1, bucket: 1 }, { unique: true });
+    schema.index({ updatedAt: 1 }, { expireAfterSeconds: 120 * 24 * 60 * 60 });
+    return mongoose.model("SecurityBaseline", schema);
+};
+exports.buildSecurityBaseline = buildSecurityBaseline;

package/build/models/security-bot-audit-event.d.ts

@@ -0,0 +1,36 @@
+import mongoose from "mongoose";
+export declare enum SecurityBotAuditType {
+    SweepStarted = "sweepStarted",
+    SweepToolCall = "sweepToolCall",
+    SweepCompleted = "sweepCompleted",
+    SweepFailed = "sweepFailed",
+    Triage = "triage",
+    FindingStatusChanged = "findingStatusChanged",
+    RuleMuted = "ruleMuted",
+    RuleUnmuted = "ruleUnmuted",
+    ControlsChanged = "controlsChanged",
+    BudgetPaused = "budgetPaused",
+    InjectionRejected = "injectionRejected"
+}
+export interface SecurityBotAuditEventDoc extends mongoose.Document {
+    type: SecurityBotAuditType;
+    sweepRunId?: string;
+    findingId?: string;
+    adminAuthId?: string;
+    adminAuthEmail?: string;
+    toolName?: string;
+    toolInput?: any;
+    ok?: boolean;
+    durationMs?: number;
+    error?: string;
+    detail?: string;
+    redactionCounts?: Record<string, number>;
+    modelId?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    estimatedUsd?: number;
+    createdAt: Date;
+}
+export type SecurityBotAuditEventModel = mongoose.Model<SecurityBotAuditEventDoc>;
+declare const buildSecurityBotAuditEvent: (mongoose: typeof mongoose) => SecurityBotAuditEventModel;
+export { buildSecurityBotAuditEvent };