@sideboard-ai/core 0.1.149 → 0.1.151

package/dist/{chunk-JTPDWTWJ.js → chunk-3JBMACYX.js}

@@ -2,26 +2,36 @@
 
 import {
   isWorkspaceScratchPath
-} from "./chunk-B3SJXYIJ.js";
+} from "./chunk-NVXVEGGM.js";
 import {
   listThreads
 } from "./chunk-EUXOHTUK.js";
+import {
+  ensureWorktreeSideboardIgnored
+} from "./chunk-SYFVUF2C.js";
 import {
   gh,
   git,
+  githubAgentAuthDir,
+  githubAgentAuthReady,
+  githubCredentialHelperGitConfig,
+  githubGhConfigEnv,
+  materializeGithubAgentAuth,
   resolveGhAuthToken
-} from "./chunk-KPIYENTF.js";
+} from "./chunk-FNQNJOHY.js";
 import {
   getGithubGitAuthMode,
   getGithubPat
-} from "./chunk-BGQBELGJ.js";
+} from "./chunk-CZD4NRDZ.js";
 import {
   worktreesRoot
 } from "./chunk-BD2ICC4D.js";
 
 // src/git/worktree.ts
-import { existsSync as existsSync2, readdirSync, realpathSync } from "fs";
-import { join as join2 } from "path";
+import { randomBytes } from "crypto";
+import { existsSync, readdirSync, realpathSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
 
 // src/git/team-meta.ts
 var SOCCER_TEAM_META = {
@@ -835,9 +845,23 @@ function worktreeDisplayLabelForGroup(threads) {
 }
 
 // src/git/gh-errors.ts
+var GITHUB_PR_BODY_MAX_CHARS = 65536;
+var GITHUB_PR_BODY_SAFE_CHARS = 6e4;
 function isGhRateLimitError(text) {
   return /API rate limit (already )?exceeded/i.test(text) || /rate limit exceeded/i.test(text);
 }
+function isGhPrBodyTooLongError(text) {
+  return /body is too long|body.{0,20}too long|maximum is 65536|exceeds the maximum allowed size|request (entity |is )?too large|payload too large|413 Request Entity Too Large/i.test(
+    text
+  );
+}
+function clampGithubPrBody(body, max = GITHUB_PR_BODY_SAFE_CHARS) {
+  const t = body.replace(/\s+$/u, "");
+  if (t.length <= max) return t;
+  const note = "\n\n_(truncated to fit GitHub\u2019s PR body limit)_";
+  const keep = Math.max(0, max - note.length);
+  return `${t.slice(0, keep).replace(/\s+$/u, "")}${note}`;
+}
 function formatRateLimitResetHint(resetEpochSec, nowMs = Date.now()) {
   const ms = resetEpochSec * 1e3 - nowMs;
   if (ms <= 0) return "soon";
@@ -848,18 +872,32 @@ function formatRateLimitResetHint(resetEpochSec, nowMs = Date.now()) {
   const hours = Math.ceil(mins / 60);
   return `in about ${hours} hour${hours === 1 ? "" : "s"}`;
 }
+function omitGhBodyArg(text) {
+  return text.replace(
+    /--body(?:-file)?(\s+|=)(?:'[^']*'|"[^"]*"|\S+)/g,
+    "--body <omitted>"
+  );
+}
+function capGhErrorText(text, max = 400) {
+  const t = text.trim();
+  if (t.length <= max) return t;
+  return `${t.slice(0, max - 1).trimEnd()}\u2026`;
+}
 function extractGhErrorDetail(text) {
-  const trimmed = text.trim();
+  const trimmed = omitGhBodyArg(text.trim());
   if (!trimmed) return "";
+  if (isGhPrBodyTooLongError(text) || isGhPrBodyTooLongError(trimmed)) {
+    return "GraphQL: body is too long (GitHub PR body / request size limit).";
+  }
   const graphql = trimmed.match(/\bGraphQL:\s*(.+)$/im);
-  if (graphql?.[1]) return `GraphQL: ${graphql[1].trim()}`;
+  if (graphql?.[1]) return capGhErrorText(`GraphQL: ${graphql[1].trim()}`);
   const http = trimmed.match(/\bHTTP\s+\d{3}:\s*(.+)$/im);
-  if (http?.[1]) return `HTTP: ${http[1].trim()}`;
+  if (http?.[1]) return capGhErrorText(`HTTP: ${http[1].trim()}`);
   const lines = trimmed.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
   if (lines.length > 1 && /^Command failed with exit code/i.test(lines[0])) {
-    return lines.slice(1).join(" ").trim() || lines[0];
+    return capGhErrorText(lines.slice(1).join(" ").trim() || lines[0]);
   }
-  return trimmed;
+  return capGhErrorText(trimmed);
 }
 function formatGhLandError(raw, opts) {
   const trimmed = raw.trim();
@@ -877,6 +915,10 @@ function formatGhLandError(raw, opts) {
     const hint = opts?.targetedRepo ? ` Branch was pushed to origin \u2014 confirm it exists on GitHub and differs from the base branch.${target}${head}.` : " Often `gh` targeted upstream instead of origin. Branch was pushed \u2014 retry in the latest Sideboard, or run: gh pr create -R <owner/name> --base main --head <branch>.";
     return `Could not create the pull request.${hint}`;
   }
+  if (isGhPrBodyTooLongError(raw) || isGhPrBodyTooLongError(detail)) {
+    const pushNote = opts?.pushed === false ? "" : " Your branch was already pushed.";
+    return `GitHub rejected the pull request: the GraphQL body is too long (PR description / request size, limit ${GITHUB_PR_BODY_MAX_CHARS} characters).${pushNote} Retry with a short title and body via \`gh pr create --body-file\` (or send_to_thread so the worktree agent writes a brief description). Do not paste a changelog or diff into --body.`;
+  }
   if (isGhRateLimitError(raw) || isGhRateLimitError(detail)) {
     const when = opts?.resetAt ? ` Try again ${formatRateLimitResetHint(opts.resetAt, opts.nowMs)}.` : " Wait a few minutes and try again.";
     const pushNote = opts?.pushed === false ? "" : " Your branch was already pushed.";
@@ -900,88 +942,29 @@ function formatMergePrError(raw) {
 
 // src/git/git-auth-mode.ts
 import { isAbsolute } from "path";
-
-// src/git/github-agent-auth.ts
-import { chmodSync, existsSync, mkdirSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
-function githubAgentAuthDir() {
-  const override = process.env.SIDEBOARD_GIT_AUTH_DIR?.trim();
-  if (override) return override;
-  return join(homedir(), ".sideboard-git-auth");
-}
-function githubCredentialStorePath() {
-  return join(githubAgentAuthDir(), "git-credentials");
-}
-function githubGhConfigDir() {
-  return join(githubAgentAuthDir(), "gh");
-}
-function writePrivateFile(file, body) {
-  mkdirSync(dirname(file), { recursive: true, mode: 448 });
-  try {
-    chmodSync(dirname(file), 448);
-  } catch {
-  }
-  writeFileSync(file, body, { encoding: "utf8", mode: 384 });
-  try {
-    chmodSync(file, 384);
-  } catch {
-  }
-}
-function gitCredentialStoreContents(token) {
-  return `https://x-access-token:${encodeURIComponent(token)}@github.com
-`;
-}
-function ghHostsYml(token, user = "x-access-token") {
-  const u = user.replace(/[^A-Za-z0-9._-]/g, "") || "x-access-token";
-  return [
-    "github.com:",
-    "    git_protocol: https",
-    `    user: ${u}`,
-    `    oauth_token: ${token}`,
-    "    users:",
-    `        ${u}:`,
-    `            oauth_token: ${token}`,
-    ""
-  ].join("\n");
-}
-function materializeGithubAgentAuth(token, user) {
-  const trimmed = token.trim();
-  if (!trimmed) return;
-  const root = githubAgentAuthDir();
-  mkdirSync(root, { recursive: true, mode: 448 });
-  try {
-    chmodSync(root, 448);
-  } catch {
-  }
-  writePrivateFile(githubCredentialStorePath(), gitCredentialStoreContents(trimmed));
-  const ghDir = githubGhConfigDir();
-  mkdirSync(ghDir, { recursive: true, mode: 448 });
-  writePrivateFile(join(ghDir, "hosts.yml"), ghHostsYml(trimmed, user));
-  writePrivateFile(join(ghDir, "config.yml"), "git_protocol: https\nprompt: disabled\n");
-}
-function githubAgentAuthReady() {
-  return existsSync(githubCredentialStorePath()) && existsSync(join(githubGhConfigDir(), "hosts.yml"));
-}
-function githubCredentialHelperGitConfig() {
-  const file = githubCredentialStorePath();
-  return [
-    { key: "credential.helper", value: "" },
-    { key: "credential.helper", value: `store --file=${file}` }
-  ];
-}
-function githubGhConfigEnv() {
-  return {
-    GH_CONFIG_DIR: githubGhConfigDir(),
-    GH_PROMPT_DISABLED: "1"
-  };
-}
-
-// src/git/git-auth-mode.ts
 var HTTPS_REWRITE = [
   { key: "url.https://github.com/.insteadOf", value: "git@github.com:" },
   { key: "url.https://github.com/.insteadOf", value: "ssh://git@github.com/" }
 ];
+function githubHttpsInsteadOfEntries(remoteUrl) {
+  const entries = [...HTTPS_REWRITE];
+  const url = remoteUrl?.trim() ?? "";
+  const scpAlias = url.match(/^(git@github\.com-[^:]+):/i);
+  if (scpAlias?.[1]) {
+    entries.push({
+      key: "url.https://github.com/.insteadOf",
+      value: `${scpAlias[1]}:`
+    });
+  }
+  const sshAlias = url.match(/^ssh:\/\/git@(github\.com-[^/]+)\//i);
+  if (sshAlias?.[1]) {
+    entries.push({
+      key: "url.https://github.com/.insteadOf",
+      value: `ssh://git@${sshAlias[1]}/`
+    });
+  }
+  return entries;
+}
 var TOKEN_TTL_MS = 12 * 60 * 60 * 1e3;
 var tokenMemo = null;
 var GITHUB_CHILD_TOKEN_KEYS = [
@@ -1011,16 +994,19 @@ function appendIndexedGitConfig(existing, entries) {
   out.GIT_CONFIG_COUNT = String(count + entries.length);
   return out;
 }
-function githubAgentGitEnv(existing) {
+function githubAgentGitEnv(existing, opts) {
   const helpers = githubAgentAuthReady() ? githubCredentialHelperGitConfig() : [{ key: "credential.helper", value: "" }];
-  return appendIndexedGitConfig(existing, [...HTTPS_REWRITE, ...helpers]);
+  return appendIndexedGitConfig(existing, [
+    ...githubHttpsInsteadOfEntries(opts?.remoteUrl),
+    ...helpers
+  ]);
 }
 function applyGithubGitAuthEnv(existing, opts) {
   const out = { ...nonInteractiveGitProcessEnv() };
   const token = opts.token?.trim() || existing?.GH_TOKEN?.trim() || "" || "";
   if (token) materializeGithubAgentAuth(token);
   Object.assign(out, githubGhConfigEnv());
-  if (opts.mode === "ssh") return out;
+  if (opts.mode === "ssh" && !token) return out;
   Object.assign(out, githubAgentGitEnv(existing));
   return out;
 }
@@ -1133,8 +1119,9 @@ function formatGitAuthModeDirective(mode) {
     case "ssh":
       return [
         "Git authentication (Settings \u2192 Git mode: SSH):",
-        "- Keep SSH remotes (`git@github.com:\u2026`). Do not rewrite them to HTTPS.",
-        "- SSH is batch-mode: it will not prompt for a Keychain password. If push fails with `Permission denied (publickey)`, tell the user to unlock ssh-agent or switch Settings \u2192 Git to Auto / gh CLI \u2014 do not rewrite remotes yourself.",
+        "- Stored remotes stay SSH (`git@github.com:\u2026`). Do not `git remote set-url` or rewrite them to HTTPS.",
+        "- This process may push over HTTPS via `gh` (process-only `insteadOf`) so ask_git / unattended turns work when ssh-agent is missing \u2014 that does not change the stored remote.",
+        "- SSH is batch-mode: it will not prompt for a Keychain password. If both SSH and HTTPS fail, tell the user to unlock ssh-agent or run `gh auth login` (or switch Settings \u2192 Git to Auto).",
         "- `gh` already authenticates for PRs/API (no token in the environment). Do not set GitHub token environment variables or run `gh auth login` from this turn.",
         "- Push with `git push -u origin HEAD`. Create/update PRs with `gh` as below."
       ].join("\n");
@@ -2228,6 +2215,16 @@ function originFetchBranch(sourceRef) {
   if (ref.startsWith("origin/")) return ref.slice("origin/".length) || null;
   return ref;
 }
+async function originRemoteUrl(cwd) {
+  const result = await git(["remote", "get-url", "origin"], cwd, { reject: false });
+  return result.exitCode === 0 ? result.stdout.trim() : "";
+}
+function githubHttpsRetryEnv(remoteUrl) {
+  return {
+    GIT_TERMINAL_PROMPT: "0",
+    ...githubAgentGitEnv(void 0, { remoteUrl })
+  };
+}
 async function fetchOriginWithAuth(repoPath, args, timeoutMs) {
   const first = await git(args, repoPath, { reject: false, timeoutMs });
   if (first.exitCode === 0) return true;
@@ -2237,15 +2234,14 @@ async function fetchOriginWithAuth(repoPath, args, timeoutMs) {
   } catch {
     return false;
   }
-  if (mode === "ssh") return false;
   const token = await resolveGithubAgentToken(mode, repoPath);
   if (!token) return false;
+  const remoteUrl = await originRemoteUrl(repoPath);
   const tryHttps = async (header) => git(args, repoPath, {
     reject: false,
     timeoutMs,
-    env: { GIT_TERMINAL_PROMPT: "0" },
+    env: githubHttpsRetryEnv(remoteUrl),
     config: {
-      "url.https://github.com/.insteadOf": "git@github.com:",
       "http.extraHeader": header
     }
   });
@@ -2327,8 +2323,8 @@ async function refreshOriginAndMaybeFastForwardMain(repoPath, sourceRef) {
 }
 async function createThreadWorktree(opts) {
   let branchName = `thread/${opts.slug}`;
-  const worktreePath = join2(worktreesRoot(opts.repoPath), opts.slug);
-  if (existsSync2(worktreePath)) {
+  const worktreePath = join(worktreesRoot(opts.repoPath), opts.slug);
+  if (existsSync(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -2363,13 +2359,14 @@ ${add.stdout}`;
   });
   branchName = added;
   await ensureGhPreferOrigin(worktreePath);
+  await ensureWorktreeSideboardIgnored(worktreePath);
   return { branchName, worktreePath };
 }
 async function createExistingBranchWorktree(opts) {
   const branchName = opts.branchName.trim();
   if (!branchName) throw new Error("branch name required");
-  const worktreePath = join2(worktreesRoot(opts.repoPath), opts.slug);
-  if (existsSync2(worktreePath)) {
+  const worktreePath = join(worktreesRoot(opts.repoPath), opts.slug);
+  if (existsSync(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -2407,6 +2404,7 @@ async function createExistingBranchWorktree(opts) {
     await git(["checkout", "-B", branchName], worktreePath, { reject: false });
   }
   await ensureGhPreferOrigin(worktreePath);
+  await ensureWorktreeSideboardIgnored(worktreePath);
   return { branchName, worktreePath };
 }
 async function removeWorktree(repoPath, worktreePath, opts) {
@@ -2495,7 +2493,9 @@ async function currentBranch(worktreePath) {
 async function commitAll(worktreePath, message) {
   const dirty = await isDirty(worktreePath);
   if (!dirty) return false;
+  await ensureWorktreeSideboardIgnored(worktreePath);
   await git(["add", "-A"], worktreePath);
+  await git(["reset", "-q", "--", ".sideboard"], worktreePath, { reject: false });
   await git(["commit", "-m", message], worktreePath);
   return true;
 }
@@ -2509,14 +2509,14 @@ async function pushBranch(worktreePath, branchName) {
   const token = await resolveGithubAgentToken(getGithubGitAuthMode(), worktreePath);
   if (!slug || !token) {
     throw new Error(
-      sshErr || `git push origin ${branchName} failed` + (!token ? " (no SSH agent and gh auth token unavailable \u2014 run: gh auth login)" : "")
+      sshErr || `git push origin ${branchName} failed` + (!token ? " (SSH remote and gh auth token unavailable \u2014 unlock ssh-agent or run: gh auth login)" : "")
     );
   }
+  const remoteUrl = await originRemoteUrl(worktreePath);
   const tryHttps = async (header) => git(["push", "-u", "origin", branchName], worktreePath, {
     reject: false,
-    env: { GIT_TERMINAL_PROMPT: "0" },
+    env: githubHttpsRetryEnv(remoteUrl),
     config: {
-      "url.https://github.com/.insteadOf": "git@github.com:",
       "http.extraHeader": header
     }
   });
@@ -2646,6 +2646,32 @@ async function createOrUpdatePr(worktreePath, opts) {
   const repoArgs = ghRepoSelectArgs(slug);
   const headRef = ghHeadRef(slug, opts.head);
   const branchOnly = opts.head.trim().replace(/^refs\/heads\//, "");
+  const bodyText = clampGithubPrBody(opts.body ?? opts.title);
+  const bodyFile = join(
+    tmpdir(),
+    `sideboard-pr-body-${process.pid}-${randomBytes(6).toString("hex")}.md`
+  );
+  writeFileSync(bodyFile, bodyText.endsWith("\n") ? bodyText : `${bodyText}
+`, "utf8");
+  const bodyArgs = ["--body-file", bodyFile];
+  try {
+    return await createOrUpdatePrWithBodyFile(worktreePath, {
+      ...opts,
+      slug,
+      repoArgs,
+      headRef,
+      branchOnly,
+      bodyArgs
+    });
+  } finally {
+    try {
+      unlinkSync(bodyFile);
+    } catch {
+    }
+  }
+}
+async function createOrUpdatePrWithBodyFile(worktreePath, opts) {
+  const { slug, repoArgs, headRef, branchOnly, bodyArgs } = opts;
   const existing = await gh(
     [...repoArgs, "pr", "view", branchOnly, "--json", "url", "--jq", ".url"],
     worktreePath,
@@ -2661,8 +2687,7 @@ async function createOrUpdatePr(worktreePath, opts) {
         branchOnly,
         "--title",
         opts.title,
-        "--body",
-        opts.body ?? opts.title
+        ...bodyArgs
       ],
       worktreePath,
       { reject: false }
@@ -2677,8 +2702,7 @@ async function createOrUpdatePr(worktreePath, opts) {
       "--web",
       "--title",
       opts.title,
-      "--body",
-      opts.body ?? opts.title,
+      ...bodyArgs,
       "--base",
       opts.base,
       "--head",
@@ -2699,8 +2723,7 @@ async function createOrUpdatePr(worktreePath, opts) {
     "create",
     "--title",
     opts.title,
-    "--body",
-    opts.body ?? opts.title,
+    ...bodyArgs,
     "--base",
     opts.base,
     "--head",
@@ -2724,8 +2747,8 @@ function sameRepoPath(a, b) {
   return normalizeWorktreePath(a) === normalizeWorktreePath(b);
 }
 function listLocalThreadBranchSlugs(repoPath) {
-  const refsDir = join2(repoPath, ".git", "refs", "heads", "thread");
-  if (!existsSync2(refsDir)) return [];
+  const refsDir = join(repoPath, ".git", "refs", "heads", "thread");
+  if (!existsSync(refsDir)) return [];
   try {
     return readdirSync(refsDir).filter((name) => !name.startsWith(".")).map((name) => normalizeTakenSlug(name));
   } catch {
@@ -2735,7 +2758,7 @@ function listLocalThreadBranchSlugs(repoPath) {
 function collectTakenTeamSlugs(repoPath) {
   const taken = /* @__PURE__ */ new Set();
   const root = worktreesRoot(repoPath);
-  if (existsSync2(root)) {
+  if (existsSync(root)) {
     for (const entry of readdirSync(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== ".DS_Store") {
         taken.add(normalizeTakenSlug(entry.name));
@@ -2757,8 +2780,8 @@ function allocateTeamSlug(repoPath) {
   const taken = collectTakenTeamSlugs(repoPath);
   for (let attempt = 0; attempt < 32; attempt++) {
     const team = allocateTeamName(taken);
-    const path = join2(worktreesRoot(repoPath), team.slug);
-    if (!existsSync2(path)) return team;
+    const path = join(worktreesRoot(repoPath), team.slug);
+    if (!existsSync(path)) return team;
     taken.add(team.slug);
   }
   throw new Error("No available soccer team worktree directories left");

package/dist/{chunk-I77RYPOH.js → chunk-4XNSGDXE.js}

@@ -250,6 +250,7 @@ var DEFAULT_AGENTS = /* @__PURE__ */ new Set([
   "cursor"
 ]);
 var GITHUB_GIT_AUTH_MODES = ["auto", "gh", "ssh", "token"];
+var FOLLOW_UP_BEHAVIORS = ["steer", "queue"];
 function emptyPublicIntegrations() {
   return {
     hasLinearApiKey: false,
@@ -573,6 +574,9 @@ function normalizeAdvanced(raw) {
   if (typeof source.orchestrationQuotaFallbackAgent === "string" && DEFAULT_AGENTS.has(source.orchestrationQuotaFallbackAgent) && source.orchestrationQuotaFallbackAgent !== "brightsy") {
     out.orchestrationQuotaFallbackAgent = source.orchestrationQuotaFallbackAgent;
   }
+  if (source.followUpBehavior === "queue" || source.followUpBehavior === "steer") {
+    out.followUpBehavior = source.followUpBehavior;
+  }
   return out;
 }
 function normalizeSettings(raw) {
@@ -1274,6 +1278,9 @@ function updateAdvancedSettings(patch) {
   if (typeof patch.orchestrationQuotaFallbackAgent === "string" && DEFAULT_AGENTS.has(patch.orchestrationQuotaFallbackAgent) && patch.orchestrationQuotaFallbackAgent !== "brightsy") {
     advanced.orchestrationQuotaFallbackAgent = patch.orchestrationQuotaFallbackAgent;
   }
+  if (patch.followUpBehavior === "queue" || patch.followUpBehavior === "steer") {
+    advanced.followUpBehavior = patch.followUpBehavior;
+  }
   return saveAppSettings({ ...current, advanced });
 }
 function autoRenameBranchEnabled(settings = loadAppSettings()) {
@@ -1319,6 +1326,9 @@ function orchestrationQuotaFallbackAgent(settings = loadAppSettings()) {
   }
   return "cursor";
 }
+function followUpBehavior(settings = loadAppSettings()) {
+  return settings.advanced.followUpBehavior === "queue" ? "queue" : "steer";
+}
 function maxConcurrentAgents(settings = loadAppSettings()) {
   const n = settings.advanced.maxConcurrent;
   if (typeof n === "number" && Number.isFinite(n)) {
@@ -1426,6 +1436,7 @@ export {
   issueSourceLabel,
   HARNESS_ENV_KEYS,
   GITHUB_GIT_AUTH_MODES,
+  FOLLOW_UP_BEHAVIORS,
   emptyPublicIntegrations,
   toPublicAppSettings,
   appSettingsPath,
@@ -1479,6 +1490,7 @@ export {
   autoCleanupOrphansEnabled,
   orchestrationQuotaOnLimit,
   orchestrationQuotaFallbackAgent,
+  followUpBehavior,
   maxConcurrentAgents,
   resolveClaudeExecutable,
   resolveAgentExecutable,