jules-orchestrator-kit 0.8.1 → 0.9.3

package/src/security.mjs

@@ -0,0 +1,212 @@
+import { normalizePath } from "./config.mjs";
+
+export const HIGH_CONFIDENCE_PATTERNS = [
+  /\bghp_[A-Za-z0-9_]{36,255}\b/g,
+  /\bgho_[A-Za-z0-9_]{36,255}\b/g,
+  /\bghu_[A-Za-z0-9_]{36,255}\b/g,
+  /\bghs_[A-Za-z0-9_]{36,255}\b/g,
+  /\bghr_[A-Za-z0-9_]{36,255}\b/g,
+
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\bASIA[0-9A-Z]{16}\b/g,
+  /\baws_secret_access_key\s*=\s*['"]?[A-Za-z0-9\/+=]{40}['"]?/g,
+
+  /-----BEGIN\s+(?:RSA|DSA|EC|OPENSSH|PRIVATE)\s+KEY-----[\s\S]*?-----END\s+(?:RSA|DSA|EC|OPENSSH|PRIVATE)\s+KEY-----/g,
+  /PuTTY-User-Key-File-[0-9]:[^\n]+/g,
+
+  /\bsk_live_[0-9a-zA-Z]{24,99}\b/g,
+  /\brk_live_[0-9a-zA-Z]{24,99}\b/g,
+  /\bnpm_[0-9a-zA-Z]{36}\b/g,
+  /\bglpat-[0-9a-zA-Z_-]{20,}\b/g,
+  /\bGOCSPX-[0-9a-zA-Z_-]{28}\b/g,
+
+  /\bAIzaSy[A-Za-z0-9_-]{33}\b/g,
+
+  /https:\/\/hooks\.slack\.com\/services\/T[A-Za-z0-9_]+\/B[A-Za-z0-9_]+\/[A-Za-z0-9_]+/g,
+
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+];
+
+export const LOW_CONFIDENCE_PATTERNS = [
+  /Bearer\s+[A-Za-z0-9._~+/-]{10,}/gi,
+  /Authorization:\s*Bearer\s+[A-Za-z0-9._~+/-]+=*/gi,
+  /\bsk_test_[0-9a-zA-Z]{24,99}\b/g,
+  /(?:api[_-]?key|secret|password|passwd|token|auth[_-]?token)\s*[:=]\s*['"]([^'"]{8,128})['"]/gi,
+];
+
+export function shannonEntropy(str) {
+  if (!str || typeof str !== "string") return 0;
+  const len = str.length;
+  const frequencies = {};
+  for (let i = 0; i < len; i++) {
+    const char = str[i];
+    frequencies[char] = (frequencies[char] || 0) + 1;
+  }
+  let entropy = 0;
+  for (const char in frequencies) {
+    const p = frequencies[char] / len;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+
+export function hasHighConfidenceSecret(text) {
+  if (!text) return false;
+  return HIGH_CONFIDENCE_PATTERNS.some((pat) => {
+    pat.lastIndex = 0;
+    const res = pat.test(text);
+    pat.lastIndex = 0;
+    return res;
+  });
+}
+
+export function hasLowConfidenceSecret(text) {
+  if (!text) return false;
+  return LOW_CONFIDENCE_PATTERNS.some((pat) => {
+    pat.lastIndex = 0;
+    const res = pat.test(text);
+    pat.lastIndex = 0;
+    return res;
+  });
+}
+
+export function redactSecrets(text) {
+  if (!text) return "";
+  let sanitized = text;
+
+  for (const [envKey, envVal] of Object.entries(process.env)) {
+    if (
+      envVal &&
+      (envVal.length >= 20 || shannonEntropy(envVal) > 3.6) &&
+      /KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL|AUTH|PASSPHRASE|URL|URI|DSN|CONNECTION|ACCOUNT/i.test(envKey)
+    ) {
+      if (sanitized.includes(envVal)) {
+        sanitized = sanitized.split(envVal).join("[REDACTED_ENV_SECRET]");
+      }
+    }
+  }
+
+  const allPatterns = [...HIGH_CONFIDENCE_PATTERNS, ...LOW_CONFIDENCE_PATTERNS];
+  for (const pat of allPatterns) {
+    pat.lastIndex = 0;
+    sanitized = sanitized.replace(pat, "[REDACTED_BY_SECURITY_GATE]");
+  }
+
+  return sanitized;
+}
+
+export function anonymizePii(text) {
+  if (!text) return "";
+  let sanitized = text;
+
+  sanitized = sanitized.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, "[REDACTED_EMAIL]");
+  sanitized = sanitized.replace(/\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/g, (ip) => {
+    if (ip === "127.0.0.1" || ip === "0.0.0.0") return ip;
+    return "[REDACTED_IP]";
+  });
+  sanitized = sanitized.replace(/(?:(?:\+\d{1,3}[\s-]?)|\b)\(?\d{2,4}\)?(?:[\s-]?\d{2,4}){2,4}\b/g, (phone) => {
+    const digitsOnly = phone.replace(/\D/g, "");
+    if (digitsOnly.length >= 7 && digitsOnly.length <= 15) {
+      return "[REDACTED_PHONE]";
+    }
+    return phone;
+  });
+
+  return sanitized;
+}
+
+export function matchesGlob(filePath, globPattern) {
+  if (!filePath || !globPattern) return false;
+  const file = normalizePath(filePath);
+  const pattern = normalizePath(globPattern);
+
+  if (file === pattern) return true;
+
+  const parts = pattern.split("/");
+  const regexParts = parts.map((part) => {
+    if (part === "**") return "___GLOBSTAR___";
+    if (part === "*") return "[^/]+";
+    const escaped = part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return escaped.replace(/\\\*/g, "[^/]*").replace(/\\\?/g, ".");
+  });
+
+  let regexStr = regexParts.join("/");
+  regexStr = regexStr
+    .replace(/^___GLOBSTAR___\//g, "(?:.*/|^)")
+    .replace(/\/___GLOBSTAR___$/g, "(?:/.*|$)")
+    .replace(/\/___GLOBSTAR___\//g, "(?:/|/.+/|/)")
+    .replace(/___GLOBSTAR___/g, ".*");
+
+  try {
+    return new RegExp(`^${regexStr}$`).test(file);
+  } catch (_) {
+    return false;
+  }
+}
+
+export function isForbiddenPath(filePath, config = {}) {
+  const normFile = normalizePath(filePath);
+  const forbidden = config.scope?.deny || config.forbidden_paths || [];
+  return forbidden.some((pattern) => matchesGlob(normFile, pattern));
+}
+
+export function checkScope(files = [], scope = {}, opts = {}) {
+  const violations = [];
+  const deny = scope.deny || [];
+  const allow = scope.allow || [];
+  const protect = scope.protect || [];
+
+  for (const rawFile of files) {
+    const file = normalizePath(rawFile);
+
+    const matchedDeny = deny.find((pat) => matchesGlob(file, pat));
+    if (matchedDeny) {
+      violations.push({ file, reason: `Forbidden path restriction matched pattern "${matchedDeny}"`, rule: "deny", pattern: matchedDeny });
+      continue;
+    }
+
+    if (allow.length > 0) {
+      const isExplicitlyAllowed = allow.some((pat) => matchesGlob(file, pat));
+      if (!isExplicitlyAllowed) {
+        violations.push({ file, reason: "Path not included in allowed paths list", rule: "allow" });
+        continue;
+      }
+    }
+
+    if (!opts.allowProtected) {
+      const matchedProtect = protect.find((pat) => matchesGlob(file, pat));
+      if (matchedProtect) {
+        violations.push({ file, reason: `Protected file modification restriction matched pattern "${matchedProtect}"`, rule: "protect", pattern: matchedProtect });
+      }
+    }
+  }
+
+  return {
+    ok: violations.length === 0,
+    violations,
+  };
+}
+
+export function scanDiff(diffTextStr = "") {
+  if (!diffTextStr) return { ok: true, findings: [] };
+  const addedLines = diffTextStr
+    .split("\n")
+    .filter((line) => line.startsWith("+") && !line.startsWith("+++"))
+    .map((line) => line.slice(1))
+    .join("\n");
+
+  const hasHigh = hasHighConfidenceSecret(addedLines);
+  const hasLow = !hasHigh && hasLowConfidenceSecret(addedLines);
+  const findings = [];
+
+  if (hasHigh) {
+    findings.push({ severity: "CRITICAL", type: "HIGH_CONFIDENCE_SECRET", description: "High-confidence secret pattern detected in added diff lines" });
+  } else if (hasLow) {
+    findings.push({ severity: "HIGH", type: "LOW_CONFIDENCE_SECRET", description: "Low-confidence secret or authorization token detected in added diff lines" });
+  }
+
+  return {
+    ok: !hasHigh && !hasLow,
+    findings,
+  };
+}

package/src/state.mjs

@@ -0,0 +1,209 @@
+import {
+  readFileSync,
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  openSync,
+  writeSync,
+  closeSync,
+  unlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { resolveRoot } from "./config.mjs";
+
+export function ensureDir(dirPath) {
+  if (!dirPath || typeof dirPath !== "string" || dirPath.includes("\0")) {
+    throw new Error("Invalid directory path provided");
+  }
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+  return dirPath;
+}
+
+export function getQueueDir(rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const dir = join(root, ".agent/jules-queue");
+  ensureDir(dir);
+  return dir;
+}
+
+export function getStateDir(rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const dir = join(root, ".agent/state");
+  ensureDir(dir);
+  return dir;
+}
+
+export function getDailyLedgerPath(rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const dateStr = new Date().toISOString().split("T")[0];
+  return join(getStateDir(root), `ledger-${dateStr}.jsonl`);
+}
+
+/**
+ * Appends a structured audit event to the daily session ledger.
+ */
+export function appendLedger(entry, rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const filePath = getDailyLedgerPath(root);
+  const payload = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+  appendFileSync(filePath, JSON.stringify(payload) + "\n", "utf-8");
+  return payload;
+}
+
+export function readLedger(filePath) {
+  if (!filePath || !existsSync(filePath)) return [];
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return raw
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => {
+        const obj = JSON.parse(line);
+        return Object.freeze(obj);
+      });
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Enforces a daily token budget.
+ */
+export function checkDailyBudget(arg1 = resolveRoot(), arg2 = 300) {
+  let root = typeof arg1 === "string" ? arg1 : resolveRoot();
+  let limit = typeof arg1 === "number" ? arg1 : typeof arg2 === "number" ? arg2 : 300;
+
+  const filePath = getDailyLedgerPath(root);
+  if (!existsSync(filePath)) {
+    return { ok: true, used: 0, budget: limit, remaining: limit };
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const count = lines.length;
+    return {
+      ok: count < limit,
+      used: count,
+      budget: limit,
+      remaining: Math.max(0, limit - count),
+    };
+  } catch (_) {
+    return { ok: true, used: 0, budget: limit, remaining: limit };
+  }
+}
+
+export async function withBudget(fn, root = resolveRoot(), limit = 300) {
+  const budget = checkDailyBudget(root, limit);
+  if (!budget.ok) {
+    throw new Error(`Daily budget exhausted (${budget.used}/${budget.budget} tasks executed)`);
+  }
+  return fn();
+}
+
+/**
+ * Atomic Advisory Lock File Manager with PID Vitality Check & Stale Lock Reaper (CWE-367 Fix).
+ */
+export function getLockDir(rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const dir = join(getStateDir(root), "locks");
+  ensureDir(dir);
+  return dir;
+}
+
+export function isPidAlive(pid) {
+  if (!pid || typeof pid !== "number") return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+export function acquireLock(agentName, taskId, files = [], rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const lockDir = getLockDir(root);
+  const lockFile = join(lockDir, `${taskId}.json`);
+
+  // Stale Lock Reaper Check
+  if (existsSync(lockFile)) {
+    try {
+      const existing = JSON.parse(readFileSync(lockFile, "utf-8"));
+      const isAlive = isPidAlive(existing.pid);
+      const isExpired = existing.acquiredAt && Date.now() - new Date(existing.acquiredAt).getTime() > 7200000;
+
+      if (!isAlive || isExpired) {
+        // Dead or expired holder; safely reap lock
+        try { unlinkSync(lockFile); } catch (_) {}
+      } else {
+        return { ok: false, holder: existing.agent, taskId, pid: existing.pid };
+      }
+    } catch (_) {
+      try { unlinkSync(lockFile); } catch (_) {}
+    }
+  }
+
+  const payload = {
+    agent: agentName,
+    taskId,
+    files,
+    pid: process.pid,
+    acquiredAt: new Date().toISOString(),
+  };
+
+  // Atomic file creation via 'wx' flag (Fixes TOCTOU Race Condition)
+  try {
+    const fd = openSync(lockFile, "wx");
+    writeSync(fd, JSON.stringify(payload, null, 2), "utf-8");
+    closeSync(fd);
+    return { ok: true, lockFile };
+  } catch (err) {
+    if (err.code === "EEXIST") {
+      try {
+        const existing = JSON.parse(readFileSync(lockFile, "utf-8"));
+        return { ok: false, holder: existing.agent, taskId };
+      } catch (_) {
+        return { ok: false, holder: "unknown", taskId };
+      }
+    }
+    throw err;
+  }
+}
+
+export function releaseLock(taskId, rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const lockDir = getLockDir(root);
+  const lockFile = join(lockDir, `${taskId}.json`);
+
+  if (existsSync(lockFile)) {
+    try {
+      unlinkSync(lockFile); // CRITICAL FIX: Fixed ESM unlinkSync (removed legacy require("node:fs"))
+      return true;
+    } catch (_) {}
+  }
+  return false;
+}
+
+export function lockStatus(rootOrOpts = resolveRoot()) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const lockDir = getLockDir(root);
+  const locks = [];
+  try {
+    const files = readdirSync(lockDir);
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          const content = readFileSync(join(lockDir, file), "utf-8");
+          locks.push(Object.freeze(JSON.parse(content)));
+        } catch (_) {}
+      }
+    }
+  } catch (_) {}
+  return locks;
+}

package/src/webhook.mjs

@@ -0,0 +1,138 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+
+/**
+ * Verify GitHub webhook HMAC SHA-256 signature against request payload.
+ * @param {Buffer|string} payload - Raw request body
+ * @param {string} signatureHeader - Value of X-Hub-Signature-256 header
+ * @param {string} secret - Configured webhook secret
+ * @returns {boolean} True if signature matches
+ */
+export function verifySignature(payload, signatureHeader, secret) {
+  if (!secret) return true; // If no secret is configured, skip verification (development mode)
+  if (!signatureHeader || !signatureHeader.startsWith("sha256=")) return false;
+
+  const hmac = createHmac("sha256", secret);
+  const bodyBuf = Buffer.isBuffer(payload) ? payload : Buffer.from(payload, "utf-8");
+  const digest = `sha256=${hmac.update(bodyBuf).digest("hex")}`;
+
+  const sigBuf = Buffer.from(signatureHeader, "utf-8");
+  const digestBuf = Buffer.from(digest, "utf-8");
+
+  if (sigBuf.length !== digestBuf.length) return false;
+  return timingSafeEqual(sigBuf, digestBuf);
+}
+
+/**
+ * Parse incoming webhook body buffer into a JS object.
+ * @param {Buffer} bodyBuf 
+ * @param {string} contentType 
+ * @returns {object} Parsed JSON payload
+ */
+export function parseWebhookPayload(bodyBuf, contentType = "application/json") {
+  const str = bodyBuf.toString("utf-8");
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const params = new URLSearchParams(str);
+    const payloadStr = params.get("payload");
+    return payloadStr ? JSON.parse(payloadStr) : {};
+  }
+  return str ? JSON.parse(str) : {};
+}
+
+/**
+ * Route and handle recognized GitHub event types.
+ * @param {string} eventType - Value of X-GitHub-Event header
+ * @param {object} payload - Parsed payload body
+ * @param {object} [handlers] - Custom action callbacks
+ * @returns {object} Response summary { handled: boolean, action: string, details: object }
+ */
+export function routeWebhookEvent(eventType, payload, handlers = {}) {
+  if (eventType === "ping") {
+    return { handled: true, action: "ping", details: { zen: payload.zen, hookId: payload.hook_id } };
+  }
+
+  if (eventType === "pull_request") {
+    const action = payload.action;
+    const prNumber = payload.number || payload.pull_request?.number;
+    const repo = payload.repository?.full_name;
+    const branch = payload.pull_request?.head?.ref;
+    const merged = payload.pull_request?.merged || false;
+
+    const details = { action, prNumber, repo, branch, merged };
+    if (typeof handlers.onPullRequest === "function") {
+      handlers.onPullRequest(details, payload);
+    }
+    return { handled: true, action: `pull_request:${action}`, details };
+  }
+
+  if (eventType === "workflow_run") {
+    const action = payload.action;
+    const name = payload.workflow?.name || payload.workflow_run?.name;
+    const conclusion = payload.workflow_run?.conclusion;
+    const repo = payload.repository?.full_name;
+
+    const details = { action, name, conclusion, repo };
+    if (typeof handlers.onWorkflowRun === "function") {
+      handlers.onWorkflowRun(details, payload);
+    }
+    return { handled: true, action: `workflow_run:${action}`, details };
+  }
+
+  return { handled: false, action: eventType, details: {} };
+}
+
+/**
+ * Create zero-dependency HTTP Webhook Server.
+ * @param {object} config
+ * @param {number} [config.port=8787]
+ * @param {string} [config.secret]
+ * @param {object} [config.handlers]
+ * @param {function} [config.log]
+ * @returns {import("node:http").Server}
+ */
+export function createWebhookServer({ _port = 8787, secret = process.env.JULES_WEBHOOK_SECRET, handlers = {}, log = console.log } = {}) {
+  const server = createServer((req, res) => {
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", timestamp: new Date().toISOString() }));
+      return;
+    }
+
+    if (req.method !== "POST") {
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Method Not Allowed" }));
+      return;
+    }
+
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const bodyBuf = Buffer.concat(chunks);
+      const sigHeader = req.headers["x-hub-signature-256"];
+      const eventType = req.headers["x-github-event"];
+      const contentType = req.headers["content-type"] || "application/json";
+
+      if (secret && !verifySignature(bodyBuf, sigHeader, secret)) {
+        log(`[Webhook] Invalid signature received from ${req.socket.remoteAddress}`);
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid signature" }));
+        return;
+      }
+
+      try {
+        const payload = parseWebhookPayload(bodyBuf, contentType);
+        const result = routeWebhookEvent(eventType, payload, handlers);
+
+        log(`[Webhook] Event: ${eventType} (${result.action}) handled=${result.handled}`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ received: true, result }));
+      } catch (err) {
+        log(`[Webhook] Error parsing payload: ${err.message}`);
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Malformed payload" }));
+      }
+    });
+  });
+
+  return server;
+}

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,63 +0,0 @@
-name: Bug Report
-description: Create a report to help us improve Jules Orchestrator Kit
-title: "[BUG] "
-labels: ["bug"]
-assignees: []
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for taking the time to fill out this bug report!
-  - type: input
-    id: version
-    attributes:
-      label: "Node.js Version"
-      description: "What version of Node.js are you using? (e.g. v20.11.0)"
-      placeholder: "v20.x"
-    validations:
-      required: true
-  - type: dropdown
-    id: package_manager
-    attributes:
-      label: "Package Manager"
-      description: "Which package manager are you using?"
-      options:
-        - npm
-        - pnpm
-        - yarn
-        - bun
-    validations:
-      required: true
-  - type: dropdown
-    id: execution_mode
-    attributes:
-      label: "Execution Mode"
-      description: "How are you running Jules?"
-      options:
-        - API Mode (JULES_API_KEY set)
-        - CLI Mode (Local jules binary)
-    validations:
-      required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: "Bug Description"
-      description: "A clear and concise description of what the bug is."
-      placeholder: "When I run npm run jules:queue..."
-    validations:
-      required: true
-  - type: textarea
-    id: reproduction
-    attributes:
-      label: "Steps to Reproduce"
-      description: "Steps to reproduce the behavior."
-      placeholder: "1. Go to...\n2. Click on...\n3. See error"
-    validations:
-      required: true
-  - type: textarea
-    id: expected
-    attributes:
-      label: "Expected Behavior"
-      description: "A clear and concise description of what you expected to happen."
-    validations:
-      required: true

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,34 +0,0 @@
-name: Feature Request
-description: Suggest an idea for Jules Orchestrator Kit
-title: "[FEATURE] "
-labels: ["enhancement"]
-assignees: []
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for suggesting a new feature!
-  - type: textarea
-    id: description
-    attributes:
-      label: "Is your feature request related to a problem? Please describe."
-      description: "A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]"
-      placeholder: "..."
-    validations:
-      required: true
-  - type: textarea
-    id: solution
-    attributes:
-      label: "Describe the solution you'd like"
-      description: "A clear and concise description of what you want to happen."
-      placeholder: "..."
-    validations:
-      required: true
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: "Describe alternatives you've considered"
-      description: "A clear and concise description of any alternative solutions or features you've considered."
-      placeholder: "..."
-    validations:
-      required: false