jules-orchestrator-kit 0.5.2 → 0.6.1

package/scripts/utils.mjs

@@ -92,3 +92,184 @@ export function resolveMarkdownConflict(content) {
 
   return result.join("\n");
 }
+
+export function calculateShannonEntropy(str) {
+  const len = str.length;
+  if (len === 0) return 0;
+  const frequencies = {};
+  for (let i = 0; i < len; i++) {
+    frequencies[str[i]] = (frequencies[str[i]] || 0) + 1;
+  }
+  return Object.values(frequencies).reduce((sum, count) => {
+    const p = count / len;
+    return sum - p * Math.log2(p);
+  }, 0);
+}
+
+export const HIGH_CONFIDENCE_PATTERNS = [
+  /\bgh[pousr]_[a-zA-Z0-9]{36,}\b/g,
+  /\bgithub_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}\b/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /\bnpm_[a-zA-Z0-9]{36}\b/g,
+  /\bsk_live_[0-9a-zA-Z]{24,}\b/g,
+];
+
+export const LOW_CONFIDENCE_PATTERNS = [
+  /\bAIza[0-9A-Za-z_-]{30,40}\b/g,
+  /\bya29\.[a-zA-Z0-9_\-]{20,}\b/g,
+  /\bBearer\s+[a-zA-Z0-9\-\._~+\/]+=*/g,
+  /\bsk-(?:ant-api03-|proj-|svcacct-)[a-zA-Z0-9\-\_]{32,}\b/g,
+  /\bxox[baprs]-[a-zA-Z0-9\-]{10,}\b/g,
+  /\beyJ[a-zA-Z0-9_\-]{10,}\.[a-zA-Z0-9_\-]{10,}\.[a-zA-Z0-9_\-]{10,}\b/g,
+  /\b(?:rk|pk)_(?:live|test)_[0-9a-zA-Z]{24,}\b/g,
+  /\bsk_test_[0-9a-zA-Z]{24,}\b/g,
+];
+
+export function hasHighConfidenceSecret(text) {
+  if (!text) return false;
+  return HIGH_CONFIDENCE_PATTERNS.some((pat) => {
+    pat.lastIndex = 0;
+    return pat.test(text);
+  });
+}
+
+export function hasLowConfidenceSecret(text) {
+  if (!text) return false;
+  return LOW_CONFIDENCE_PATTERNS.some((pat) => {
+    pat.lastIndex = 0;
+    return pat.test(text);
+  });
+}
+
+export function redactSecrets(text) {
+  if (!text) return "";
+  let sanitized = text;
+
+  for (const [envKey, envVal] of Object.entries(process.env)) {
+    if (
+      envVal &&
+      (envVal.length >= 20 || calculateShannonEntropy(envVal) > 3.6) &&
+      /KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL|AUTH/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) {
+    sanitized = sanitized.replace(pat, "[REDACTED_BY_SECURITY_GATE]");
+  }
+  return sanitized;
+}
+
+export function appendLedger(ledgerName, payload) {
+  const stateDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/state");
+  ensureDir(stateDir);
+  const ledgerPath = path.join(stateDir, `${ledgerName}.jsonl`);
+  const entry = JSON.stringify({
+    timestamp: new Date().toISOString(),
+    ...payload
+  }) + "\n";
+  fs.appendFileSync(ledgerPath, entry, "utf-8");
+  return ledgerPath;
+}
+
+export function checkDailyBudget(maxSessions = 300) {
+  const dateStr = new Date().toISOString().split("T")[0];
+  const stateDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/state");
+  const sessionsLedger = path.join(stateDir, "sessions.jsonl");
+  
+  if (!fs.existsSync(sessionsLedger)) {
+    return { ok: true, used: 0, budget: maxSessions };
+  }
+
+  const content = fs.readFileSync(sessionsLedger, "utf-8");
+  const lines = content.split("\n").filter(Boolean);
+  
+  let usedToday = 0;
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (
+        entry.timestamp &&
+        entry.timestamp.startsWith(dateStr) &&
+        (entry.event === "budget_reserved" || !entry.event)
+      ) {
+        usedToday++;
+      }
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  return { ok: usedToday < maxSessions, used: usedToday, budget: maxSessions };
+}
+
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch (_) {}
+}
+
+export function reserveDailyBudget(maxSessions = 300, taskKey = "") {
+  const stateDir = path.resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/state");
+  ensureDir(stateDir);
+
+  const lockFile = path.join(stateDir, "budget.lock");
+  let fd;
+  const maxLockAttempts = 10;
+
+  for (let attempt = 0; attempt < maxLockAttempts; attempt++) {
+    try {
+      try {
+        const stat = fs.statSync(lockFile);
+        if (Date.now() - stat.mtimeMs > 30000) {
+          fs.rmSync(lockFile, { force: true });
+        }
+      } catch (_) {}
+
+      fd = fs.openSync(lockFile, "wx");
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      if (attempt < maxLockAttempts - 1) {
+        sleepSync(Math.floor(50 + Math.random() * 50));
+      }
+    }
+  }
+
+  if (fd === undefined) {
+    return { ok: false, reason: "locked", used: null, budget: maxSessions };
+  }
+
+  try {
+    const check = checkDailyBudget(maxSessions);
+    if (!check.ok) {
+      return check;
+    }
+
+    appendLedger("sessions", {
+      event: "budget_reserved",
+      task_key: taskKey,
+      status: "reserved"
+    });
+
+    return {
+      ok: true,
+      used: check.used + 1,
+      budget: maxSessions
+    };
+  } finally {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch {}
+      try {
+        fs.rmSync(lockFile, { force: true });
+      } catch {}
+    }
+  }
+}