jules-orchestrator-kit 0.53.0 → 0.54.1

package/src/security.mjs

@@ -1,4 +1,4 @@
-import { openSync, writeSync, fsyncSync, closeSync, renameSync, realpathSync, existsSync, lstatSync, unlinkSync } from "node:fs";
+import { openSync, readFileSync, writeSync, fsyncSync, closeSync, renameSync, realpathSync, existsSync, lstatSync, unlinkSync } from "node:fs";
 import { dirname, join, basename } from "node:path";
 import { randomBytes } from "node:crypto";
 import { canonicalizePath, isWindowsAbsolutePath } from "./config.mjs";
@@ -911,6 +911,102 @@ export function hasHighEntropyToken(text = "", file = null) {
   return false;
 }
 
+/** Bytes of any one binary file the scanner will read. */
+const BINARY_SCAN_CAP_BYTES = 8 * 1024 * 1024;
+
+/** Runs of printable ASCII at least this long are worth classifying. */
+const BINARY_STRING_MIN_RUN = 8;
+
+/**
+ * Scan the contents of files git summarised as "Binary files ... differ".
+ *
+ * Everything else in this module reads the diff *text*, and git renders a
+ * binary file as one 43-byte summary line — so a credential became invisible to
+ * the entire scanner by prefixing the file with a single NUL byte. That is not
+ * a theoretical bypass: `printf '\0ghp_...' > secret.dat` walked a live GitHub
+ * token straight through a green gate.
+ *
+ * Only the *structured* high-confidence patterns are applied here, never
+ * entropy. A real PNG is full of high-entropy bytes and would fail every gate
+ * it touched; a string matching `ghp_[A-Za-z0-9]{36}` inside a file claiming to
+ * be an image is not a coincidence.
+ *
+ * @param {Array<{ file: string, bytes: number }>} entries
+ * @param {string} root
+ * @param {object} [opts]
+ * @param {number} [opts.capBytes] - per-file read ceiling
+ * @returns {Array<{ severity: string, type: string, file: string, line: null, description: string }>}
+ */
+export function scanBinaryPayloads(entries = [], root = process.cwd(), opts = {}) {
+  const cap = Number.isFinite(opts.capBytes) ? opts.capBytes : BINARY_SCAN_CAP_BYTES;
+  const findings = [];
+  // `entries` comes from a git call that returns null on failure, and the
+  // default parameter only covers `undefined`.
+  const list = Array.isArray(entries) ? entries : [];
+
+  for (const entry of list) {
+    if (!entry || !entry.file) continue;
+    // A file too large to read is reported rather than skipped: silence here is
+    // exactly the hole being closed.
+    if (entry.bytes > cap) {
+      findings.push({
+        severity: "HIGH",
+        type: "BINARY_PAYLOAD_UNSCANNED",
+        file: entry.file,
+        line: null,
+        description: `Binary file ${entry.file} is ${Math.round(entry.bytes / 1024)} KB, above the ${Math.round(cap / 1024)} KB scan ceiling, and was not inspected for credentials`,
+      });
+      continue;
+    }
+
+    let buf;
+    try {
+      buf = readFileSync(join(root, entry.file));
+    } catch (_) {
+      continue;
+    }
+
+    // Extract printable runs the way `strings(1)` does: a credential inside a
+    // binary is still ASCII, and decoding the whole buffer as UTF-8 would let
+    // replacement characters split the token apart.
+    const runs = [];
+    let current = "";
+    for (const byte of buf) {
+      if (byte >= 0x20 && byte <= 0x7e) {
+        current += String.fromCharCode(byte);
+      } else {
+        if (current.length >= BINARY_STRING_MIN_RUN) runs.push(current);
+        current = "";
+      }
+    }
+    if (current.length >= BINARY_STRING_MIN_RUN) runs.push(current);
+    if (runs.length === 0) continue;
+
+    const text = runs.join("\n");
+    if (hasHighConfidenceSecret(text)) {
+      findings.push({
+        severity: "CRITICAL",
+        type: "HIGH_CONFIDENCE_SECRET",
+        file: entry.file,
+        line: null,
+        description: `High-confidence secret pattern found inside binary file ${entry.file}, which the diff renders only as "Binary files ... differ"`,
+      });
+      continue;
+    }
+    if (hasEncodedSecret(text)) {
+      findings.push({
+        severity: "CRITICAL",
+        type: "HIGH_CONFIDENCE_SECRET",
+        file: entry.file,
+        line: null,
+        description: `Base64-encoded secret found inside binary file ${entry.file}`,
+      });
+    }
+  }
+
+  return findings;
+}
+
 /**
  * Classify a block of added lines. Returns the single most severe finding, or
  * null when the block is clean.

package/src/wizard-init.mjs

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync, writeFileSync, openSync, fsyncSync, closeSync, renameSync, mkdirSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parseYaml, TIER_PRESETS, VENDOR_TIERS, FALLBACK_TIER } from "./config.mjs";
-import { suggestProvider } from "./provider-readiness.mjs";
-import { PROFILE_NAMES } from "./profiles.mjs";
+import { suggestProvider, detectAvailableProviders } from "./provider-readiness.mjs";
+import { detectDefaultBranch } from "./git.mjs";
+import { PROFILE_NAMES, PROFILE_DESCRIPTIONS } from "./profiles.mjs";
 import { detectStackOracles, runVerificationProbe } from "./wizard-oracle.mjs";
 import { select, multiSelect, input, confirm, spinner, isTTY } from "./tui.mjs";
 import { KIT_VERSION } from "./version.mjs";
@@ -174,6 +175,11 @@ export function planInit(root = process.cwd(), options = {}) {
   const requestedProfile = String(options.profile || existingConfig.verify?.profile || "standard").toLowerCase();
   const profile = PROFILE_NAMES.includes(requestedProfile) ? requestedProfile : "standard";
 
+  // Detected, not assumed. A hardcoded `main` made the very first
+  // `agentctl check` fail with an unresolvable base ref in every repository
+  // whose git chose `master`, or whose team standardised on `develop`.
+  const baseBranch = options.baseBranch || existingConfig.base_branch || detectDefaultBranch(root);
+
   const limitsBlock = isCustomLimits
     ? `\nlimits:\n  concurrency: ${limits.concurrency}\n  daily_tasks: ${limits.daily_tasks}\n  stagger_ms: ${limits.stagger_ms}\n  diff_kb: ${limits.diff_kb}\n`
     : "";
@@ -183,7 +189,7 @@ export function planInit(root = process.cwd(), options = {}) {
 version: 1
 provider: ${provider}
 tier: ${tierName}
-base_branch: ${options.baseBranch || existingConfig.base_branch || "main"}
+base_branch: ${baseBranch}
 branch_prefix: ${existingConfig.branch_prefix || "agent/"}
 ${limitsBlock}
 verify:
@@ -229,6 +235,7 @@ allow_paths: ${allowPaths.length > 0 ? "\n" + allowPaths.map((p) => `  - "${p}"`
     tier: tierName,
     provider,
     profile,
+    baseBranch,
     verify,
     limits,
     presets: selectedPresets,
@@ -292,6 +299,8 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
   }
 
   let selectedTier = options.tier || existingConfig.tier || FALLBACK_TIER;
+  let selectedProvider = options.provider || existingConfig.provider;
+  let selectedProfile = options.profile || existingConfig.verify?.profile;
   let testCmd = options.testCmd;
   let buildCmd = options.buildCmd;
   let selectedPresets = options.presets;
@@ -302,14 +311,51 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
     await new Promise((resolve) => setTimeout(resolve, 300));
     sp.stop(`Detected Stack: ${oracle.stack}`);
 
-    const optionsList = tierOptions();
-    const defaultTierIdx = Math.max(0, optionsList.findIndex((t) => t.value === selectedTier));
-
-    selectedTier = await select(
-      optionsList,
-      "Which plan does your Jules account use? (limits are adjustable later)",
-      { ...options, defaultIdx: defaultTierIdx }
+    // Which agent, before anything about one vendor's plans.
+    //
+    // The wizard's first question used to be "Which plan does your Jules
+    // account use?", asked of everyone — including people who came to drive
+    // Claude Code or Codex and were now left guessing whether a Jules
+    // subscription was a prerequisite. Ask what the repository is for first,
+    // and ask the plan question only of the provider it belongs to.
+    const probes = detectAvailableProviders({ env: options.env || process.env });
+    const providerOptions = probes.map((pr) => ({
+      label: `${pr.name}${pr.ready ? "" : "  (not available here)"}`,
+      value: pr.name,
+      hint: pr.ready ? pr.label : `${pr.label} — ${pr.remedy}`,
+    }));
+    const defaultProviderIdx = Math.max(
+      0,
+      providerOptions.findIndex((o) => o.value === (selectedProvider || probes.find((pr) => pr.ready)?.name))
     );
+    selectedProvider = await select(providerOptions, "Which agent should run the tasks?", {
+      ...options,
+      defaultIdx: defaultProviderIdx,
+    });
+
+    // Only the hosted provider meters work against an account plan; asking a
+    // local-CLI user about tiers is asking about something that does not exist
+    // for them.
+    if (selectedProvider === "jules") {
+      const optionsList = tierOptions();
+      const defaultTierIdx = Math.max(0, optionsList.findIndex((t) => t.value === selectedTier));
+      selectedTier = await select(
+        optionsList,
+        "Which plan does your Jules account use? (limits are adjustable later)",
+        { ...options, defaultIdx: defaultTierIdx }
+      );
+    }
+
+    const profileOptions = PROFILE_NAMES.map((n) => ({
+      label: n,
+      value: n,
+      hint: PROFILE_DESCRIPTIONS[n],
+    }));
+    const defaultProfileIdx = Math.max(0, profileOptions.findIndex((o) => o.value === (selectedProfile || "standard")));
+    selectedProfile = await select(profileOptions, "How hard should the gate verify agent work?", {
+      ...options,
+      defaultIdx: defaultProfileIdx,
+    });
 
     testCmd = await input("Verification Test Command", {
       defaultValue: testCmd || existingConfig.verify?.test || oracle.candidates.testCmd || "npm test",
@@ -357,6 +403,8 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
   const plan = planInit(root, {
     ...options,
     tier: selectedTier,
+    provider: selectedProvider,
+    profile: selectedProfile,
     testCmd,
     buildCmd,
     presets: selectedPresets,

package/src/wizard-task.mjs

@@ -257,7 +257,8 @@ ${fullPrompt}
  * Run interactive or headless task creation wizard.
  * @param {string} [root=process.cwd()]
  * @param {object} [options]
- * @returns {Promise<{ ok: boolean, taskFile: string, plan: object }>}
+ * @param {boolean} [options.dryRun] - synthesize and validate the envelope without writing it
+ * @returns {Promise<{ ok: boolean, dryRun: boolean, taskFile: string, written: boolean, plan: object }>}
  */
 export async function runTaskCreateWizard(root = process.cwd(), options = {}) {
   const interactive = options.interactive !== false && isTTY(options.stdin || process.stdin);
@@ -338,20 +339,36 @@ export async function runTaskCreateWizard(root = process.cwd(), options = {}) {
 
   // Write Task File to canonical queue directory (getQueueDir)
   const queueDir = getQueueDir(root);
-  if (!existsSync(queueDir)) {
-    mkdirSync(queueDir, { recursive: true });
-  }
-
   const taskFile = resolve(queueDir, `${plan.taskId}.md`);
   if (!taskFile.startsWith(resolve(queueDir))) {
     throw new Error("Task ID path traversal blocked.");
   }
 
+  // `--dry-run` was accepted by the CLI parser and then dropped on the floor:
+  // the envelope was written to the queue either way, so a rehearsal queued
+  // real work. A rehearsal returns the same plan and touches nothing — not even
+  // the queue directory, which would otherwise be created as a side effect.
+  if (options.dryRun) {
+    return {
+      ok: true,
+      dryRun: true,
+      taskFile,
+      written: false,
+      plan,
+    };
+  }
+
+  if (!existsSync(queueDir)) {
+    mkdirSync(queueDir, { recursive: true });
+  }
+
   writeFileSync(taskFile, plan.taskFileContent, "utf-8");
 
   return {
     ok: true,
+    dryRun: false,
     taskFile,
+    written: true,
     plan,
   };
 }

package/src/profiles-io.mjs

@@ -1,77 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, renameSync } from "node:fs";
-import { join } from "node:path";
-import { PROFILE_NAMES } from "./profiles.mjs";
-
-/**
- * Set `verify.profile` in the repository's manifest, in place.
- *
- * A surgical text edit rather than a parse-and-reserialise: the kit's YAML
- * reader is a subset parser, so round-tripping the file through it would drop
- * every comment the wizard wrote and any key the subset does not model. The
- * manifest is a file a human maintains; a tool that rewrites it must leave the
- * rest of it alone.
- *
- * @param {string} root
- * @param {string} profile - one of {@link PROFILE_NAMES}
- * @returns {{ ok: boolean, file?: string, error?: string }}
- */
-export function setVerificationProfile(root, profile) {
-  const name = String(profile || "").toLowerCase();
-  if (!PROFILE_NAMES.includes(name)) {
-    return { ok: false, error: `Unknown profile '${profile}'. Choose one of: ${PROFILE_NAMES.join(", ")}` };
-  }
-
-  const candidates = [join(root, ".agent", "config.yml"), join(root, ".agent", "jules.yml")];
-  const file = candidates.find((f) => existsSync(f));
-  if (!file) {
-    return { ok: false, error: "No .agent/config.yml found. Run `agentctl init` first." };
-  }
-
-  let text;
-  try {
-    text = readFileSync(file, "utf-8");
-  } catch (err) {
-    return { ok: false, error: `Could not read ${file}: ${err.message}` };
-  }
-
-  const eol = text.includes("\r\n") ? "\r\n" : "\n";
-  const lines = text.split(/\r?\n/);
-
-  // Find the `verify:` mapping and the `profile:` key nested directly under it.
-  let verifyIdx = -1;
-  let profileIdx = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (/^verify:\s*$/.test(lines[i])) {
-      verifyIdx = i;
-      for (let j = i + 1; j < lines.length; j++) {
-        // A non-indented, non-blank line ends the block.
-        if (lines[j].trim() !== "" && !/^\s/.test(lines[j])) break;
-        if (/^\s+profile:\s*/.test(lines[j])) {
-          profileIdx = j;
-          break;
-        }
-      }
-      break;
-    }
-  }
-
-  if (profileIdx >= 0) {
-    const indent = lines[profileIdx].match(/^(\s*)/)[1];
-    lines[profileIdx] = `${indent}profile: ${name}`;
-  } else if (verifyIdx >= 0) {
-    lines.splice(verifyIdx + 1, 0, `  profile: ${name}`);
-  } else {
-    if (lines.length && lines[lines.length - 1] !== "") lines.push("");
-    lines.push("verify:", `  profile: ${name}`, "");
-  }
-
-  const tmp = `${file}.tmp-${process.pid}`;
-  try {
-    writeFileSync(tmp, lines.join(eol), "utf-8");
-    renameSync(tmp, file);
-  } catch (err) {
-    return { ok: false, error: `Could not write ${file}: ${err.message}` };
-  }
-
-  return { ok: true, file };
-}