@sideboard-ai/core 0.1.258 → 0.1.262

package/dist/chunk-CEMNIGQH.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+
+import {
+  appDataDir
+} from "./chunk-Z2LGMV6C.js";
+
+// src/store/managed-accounts.ts
+import { existsSync, mkdirSync, copyFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var EMPTY_MANAGED_ACCOUNTS = {
+  accounts: [],
+  activeClaudeAccountId: null,
+  activeCodexAccountId: null
+};
+function isManagedAccountKind(value) {
+  return value === "claude" || value === "codex";
+}
+function systemConfigDir(kind) {
+  return kind === "claude" ? join(homedir(), ".claude") : join(homedir(), ".codex");
+}
+function managedAccountConfigDir(kind, id) {
+  return join(appDataDir(), "accounts", kind, id);
+}
+function activeAccountId(kind, state) {
+  return kind === "claude" ? state.activeClaudeAccountId : state.activeCodexAccountId;
+}
+function findManagedAccount(state, id, kind) {
+  if (!id) return null;
+  return state.accounts.find((a) => a.id === id && (kind == null || a.kind === kind)) ?? null;
+}
+function resolveAccountForThread(thread, state) {
+  if (thread.agent !== "claude" && thread.agent !== "codex") return null;
+  const kind = thread.agent;
+  if (thread.accountId !== void 0) {
+    return findManagedAccount(state, thread.accountId, kind);
+  }
+  return findManagedAccount(state, activeAccountId(kind, state), kind);
+}
+function accountIdToPin(thread, state) {
+  if (thread.agent !== "claude" && thread.agent !== "codex") return void 0;
+  if (thread.accountId !== void 0) return thread.accountId;
+  return activeAccountId(thread.agent, state);
+}
+function applyManagedAccountEnv(env, agent, account) {
+  if (!account) return;
+  if (agent === "claude" && account.kind === "claude") {
+    env.CLAUDE_CONFIG_DIR = account.configDir;
+  }
+  if (agent === "codex" && account.kind === "codex") {
+    env.CODEX_HOME = account.configDir;
+  }
+}
+function nextManagedAccount(kind, currentId, state) {
+  const list = state.accounts.filter((a) => a.kind === kind);
+  if (list.length === 0) return null;
+  const slots = [
+    { accountId: null, label: "System default" },
+    ...list.map((a) => ({ accountId: a.id, label: a.label }))
+  ];
+  const idx = slots.findIndex((s) => s.accountId === (currentId ?? null));
+  const from = idx < 0 ? 0 : idx;
+  const next = slots[(from + 1) % slots.length];
+  if (!next || next.accountId === (currentId ?? null)) return null;
+  return next;
+}
+function ensureManagedAccountDir(kind, id) {
+  const dir = managedAccountConfigDir(kind, id);
+  mkdirSync(dir, { recursive: true });
+  mirrorHostConfig(kind, dir);
+  return dir;
+}
+function mirrorHostConfig(kind, destDir) {
+  const src = systemConfigDir(kind);
+  const files = kind === "claude" ? ["settings.json"] : ["config.toml"];
+  for (const name of files) {
+    const from = join(src, name);
+    const to = join(destDir, name);
+    if (!existsSync(from) || existsSync(to)) continue;
+    try {
+      copyFileSync(from, to);
+    } catch {
+    }
+  }
+}
+function normalizeManagedAccounts(raw) {
+  if (!raw || typeof raw !== "object") return { ...EMPTY_MANAGED_ACCOUNTS };
+  const source = raw;
+  const accounts = [];
+  if (Array.isArray(source.accounts)) {
+    for (const item of source.accounts) {
+      if (!item || typeof item !== "object") continue;
+      const rec = item;
+      if (typeof rec.id !== "string" || !rec.id.trim()) continue;
+      if (!isManagedAccountKind(rec.kind)) continue;
+      if (typeof rec.label !== "string" || !rec.label.trim()) continue;
+      if (typeof rec.configDir !== "string" || !rec.configDir.trim()) continue;
+      accounts.push({
+        id: rec.id.trim(),
+        kind: rec.kind,
+        label: rec.label.trim().slice(0, 80),
+        configDir: rec.configDir.trim(),
+        createdAt: typeof rec.createdAt === "string" && rec.createdAt.trim() ? rec.createdAt.trim() : (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  const claudeId = typeof source.activeClaudeAccountId === "string" && source.activeClaudeAccountId.trim() ? source.activeClaudeAccountId.trim() : null;
+  const codexId = typeof source.activeCodexAccountId === "string" && source.activeCodexAccountId.trim() ? source.activeCodexAccountId.trim() : null;
+  return {
+    accounts,
+    activeClaudeAccountId: accounts.some((a) => a.id === claudeId && a.kind === "claude") ? claudeId : null,
+    activeCodexAccountId: accounts.some((a) => a.id === codexId && a.kind === "codex") ? codexId : null
+  };
+}
+function withAddedAccount(state, account) {
+  const accounts = [...state.accounts.filter((a) => a.id !== account.id), account];
+  if (account.kind === "claude") {
+    return { ...state, accounts, activeClaudeAccountId: account.id };
+  }
+  return { ...state, accounts, activeCodexAccountId: account.id };
+}
+function withSelectedAccount(state, kind, accountId) {
+  if (accountId && !findManagedAccount(state, accountId, kind)) {
+    accountId = null;
+  }
+  if (kind === "claude") return { ...state, activeClaudeAccountId: accountId };
+  return { ...state, activeCodexAccountId: accountId };
+}
+function withRemovedAccount(state, id) {
+  const accounts = state.accounts.filter((a) => a.id !== id);
+  return {
+    accounts,
+    activeClaudeAccountId: state.activeClaudeAccountId === id ? null : state.activeClaudeAccountId,
+    activeCodexAccountId: state.activeCodexAccountId === id ? null : state.activeCodexAccountId
+  };
+}
+function loginEnvPrefix(account) {
+  const key = account.kind === "claude" ? "CLAUDE_CONFIG_DIR" : "CODEX_HOME";
+  const escaped = account.configDir.replace(/'/g, `'\\''`);
+  return `export ${key}='${escaped}'`;
+}
+
+export {
+  EMPTY_MANAGED_ACCOUNTS,
+  isManagedAccountKind,
+  systemConfigDir,
+  managedAccountConfigDir,
+  activeAccountId,
+  findManagedAccount,
+  resolveAccountForThread,
+  accountIdToPin,
+  applyManagedAccountEnv,
+  nextManagedAccount,
+  ensureManagedAccountDir,
+  mirrorHostConfig,
+  normalizeManagedAccounts,
+  withAddedAccount,
+  withSelectedAccount,
+  withRemovedAccount,
+  loginEnvPrefix
+};

package/dist/{chunk-66LAOKLK.js → chunk-D554YCHG.js}

@@ -4,14 +4,14 @@ import {
   normalizeAbleTimeCredential,
   normalizeAbleTimeHost,
   rewriteAbleTimeError
-} from "./chunk-IFHHPPSL.js";
+} from "./chunk-J6ONZP74.js";
 import {
   httpFetch
 } from "./chunk-N7WZ6NIN.js";
 import {
   getAbleTimeAccessToken,
   getAbleTimeHost
-} from "./chunk-KJM3E3NF.js";
+} from "./chunk-6PFZ6XO7.js";
 
 // src/integrations/abletime-rest.ts
 var ABLETIME_REST_PREFIX = "/api/public/v2";

package/dist/{chunk-HCNCZPDL.js → chunk-FSZ7YYFQ.js}

@@ -2,10 +2,7 @@
 
 import {
   isWorkspaceScratchPath
-} from "./chunk-D6JWYJ4P.js";
-import {
-  listThreads
-} from "./chunk-RJC2MKXN.js";
+} from "./chunk-N2WW62LF.js";
 import {
   ensureWorktreeSideboardIgnored
 } from "./chunk-DD67JWTN.js";
@@ -22,16 +19,19 @@ import {
 import {
   getGithubGitAuthMode,
   getGithubPat
-} from "./chunk-452Y24PW.js";
+} from "./chunk-VIC6TDYT.js";
+import {
+  listThreads
+} from "./chunk-TJ673EZT.js";
 import {
   worktreesRoot
 } from "./chunk-Z2LGMV6C.js";
 
 // src/git/worktree.ts
 import { randomBytes } from "crypto";
-import { existsSync, readdirSync, realpathSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, realpathSync, unlinkSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 
 // src/git/team-meta.ts
 var SOCCER_TEAM_META = {
@@ -881,6 +881,42 @@ function worktreeDisplayLabelForGroup(threads) {
   const canonical = [...threads].sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
   return threadDisplayLabel(canonical);
 }
+function agentNicknameFromWorktreePath(worktreePath) {
+  const dir = worktreeNameFromPath(worktreePath);
+  if (!soccerTokenFromTakenSlug(dir)) return null;
+  return teamNameFromSlug(dir);
+}
+function worktreeIdentityTitles(thread, parentTitle) {
+  const out = [];
+  const push = (value) => {
+    const trimmed = value?.trim();
+    if (trimmed) out.push(trimmed);
+  };
+  push(parentTitle);
+  push(thread.prTitle);
+  const branch = thread.branchName?.trim() ?? "";
+  const path = thread.worktreePath?.trim() ?? "";
+  if (branch && path && branch !== "HEAD" && !isPlaceholderBranch(branch, path)) {
+    push(branch);
+  }
+  return out;
+}
+function foldLabel(value) {
+  return value.trim().replace(/[.…]+$/g, "").replace(/\s+/g, " ").toLowerCase();
+}
+function isWorktreeIdentityTitle(title, identities) {
+  const a = foldLabel(title);
+  if (!a || a === "untitled" || a === "new agent") return true;
+  for (const identity of identities) {
+    const b = foldLabel(identity);
+    if (!b) continue;
+    if (a === b) return true;
+    const shorter = a.length <= b.length ? a : b;
+    const longer = a.length <= b.length ? b : a;
+    if (shorter.length >= 20 && longer.startsWith(shorter)) return true;
+  }
+  return false;
+}
 
 // src/git/gh-errors.ts
 var GITHUB_PR_BODY_MAX_CHARS = 65536;
@@ -1863,6 +1899,70 @@ async function addPrStackLayer(cwd, branchName) {
   }
 }
 
+// src/git/team-slugs.ts
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+function sameRepoPath(a, b) {
+  return normalizeWorktreePath(a) === normalizeWorktreePath(b);
+}
+function listLocalPlaceholderBranchSlugs(repoPath) {
+  const slugs = [];
+  const headsDir = join(repoPath, ".git", "refs", "heads");
+  const threadDir = join(headsDir, "thread");
+  try {
+    if (existsSync(threadDir)) {
+      for (const name of readdirSync(threadDir)) {
+        if (!name.startsWith(".")) slugs.push(normalizeTakenSlug(name));
+      }
+    }
+    if (existsSync(headsDir)) {
+      for (const entry of readdirSync(headsDir, { withFileTypes: true })) {
+        if (entry.isFile() && !entry.name.startsWith(".")) {
+          slugs.push(normalizeTakenSlug(entry.name));
+        }
+      }
+    }
+  } catch {
+    return slugs;
+  }
+  return slugs;
+}
+function collectTakenTeamSlugs(repoPath) {
+  const taken = /* @__PURE__ */ new Set();
+  const root = worktreesRoot(repoPath);
+  if (existsSync(root)) {
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== ".DS_Store") {
+        for (const slug of takenSlugsFromThread({ worktreePath: entry.name })) {
+          taken.add(slug);
+        }
+      }
+    }
+  }
+  for (const slug of listLocalPlaceholderBranchSlugs(repoPath)) {
+    for (const token of takenSlugsFromThread({ branchName: slug })) {
+      taken.add(token);
+    }
+  }
+  for (const thread of listThreads({ includeArchived: true })) {
+    if (!sameRepoPath(thread.repoPath, repoPath)) continue;
+    for (const slug of takenSlugsFromThread(thread)) {
+      taken.add(slug);
+    }
+  }
+  return taken;
+}
+function allocateTeamSlug(repoPath) {
+  const taken = collectTakenTeamSlugs(repoPath);
+  for (let attempt = 0; attempt < 32; attempt++) {
+    const team = allocateTeamName(taken);
+    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");
+}
+
 // src/git/worktree.ts
 async function lookupGithubGraphqlReset(cwd) {
   const result = await gh(["api", "rate_limit"], cwd, { reject: false });
@@ -2821,9 +2921,9 @@ async function refreshOriginAndMaybeFastForwardMain(repoPath, sourceRef) {
   await fastForwardMainCheckoutIfSafe(repoPath, { branch: def });
 }
 async function createThreadWorktree(opts) {
-  let branchName = `thread/${opts.slug}`;
-  const worktreePath = join(worktreesRoot(opts.repoPath), opts.slug);
-  if (existsSync(worktreePath)) {
+  let branchName = opts.slug;
+  const worktreePath = join2(worktreesRoot(opts.repoPath), opts.slug);
+  if (existsSync2(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -2864,8 +2964,8 @@ ${add.stdout}`;
 async function createExistingBranchWorktree(opts) {
   const branchName = opts.branchName.trim();
   if (!branchName) throw new Error("branch name required");
-  const worktreePath = join(worktreesRoot(opts.repoPath), opts.slug);
-  if (existsSync(worktreePath)) {
+  const worktreePath = join2(worktreesRoot(opts.repoPath), opts.slug);
+  if (existsSync2(worktreePath)) {
     throw new Error(`Worktree already exists at ${worktreePath}`);
   }
   await ensureGhPreferOrigin(opts.repoPath);
@@ -3204,7 +3304,7 @@ async function createOrUpdatePr(worktreePath, opts) {
   const headRef = ghHeadRef(slug, opts.head);
   const branchOnly = opts.head.trim().replace(/^refs\/heads\//, "");
   const bodyText = clampGithubPrBody(opts.body ?? opts.title);
-  const bodyFile = join(
+  const bodyFile = join2(
     tmpdir(),
     `sideboard-pr-body-${process.pid}-${randomBytes(6).toString("hex")}.md`
   );
@@ -3302,53 +3402,6 @@ function suggestSlug(source) {
   const stamp = Date.now().toString(36).slice(-4);
   return `${base || "thread"}-${stamp}`;
 }
-function sameRepoPath(a, b) {
-  return normalizeWorktreePath(a) === normalizeWorktreePath(b);
-}
-function listLocalThreadBranchSlugs(repoPath) {
-  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 {
-    return [];
-  }
-}
-function collectTakenTeamSlugs(repoPath) {
-  const taken = /* @__PURE__ */ new Set();
-  const root = worktreesRoot(repoPath);
-  if (existsSync(root)) {
-    for (const entry of readdirSync(root, { withFileTypes: true })) {
-      if (entry.isDirectory() && entry.name !== ".DS_Store") {
-        for (const slug of takenSlugsFromThread({ worktreePath: entry.name })) {
-          taken.add(slug);
-        }
-      }
-    }
-  }
-  for (const slug of listLocalThreadBranchSlugs(repoPath)) {
-    for (const token of takenSlugsFromThread({ branchName: slug })) {
-      taken.add(token);
-    }
-  }
-  for (const thread of listThreads({ includeArchived: true })) {
-    if (!sameRepoPath(thread.repoPath, repoPath)) continue;
-    for (const slug of takenSlugsFromThread(thread)) {
-      taken.add(slug);
-    }
-  }
-  return taken;
-}
-function allocateTeamSlug(repoPath) {
-  const taken = collectTakenTeamSlugs(repoPath);
-  for (let attempt = 0; attempt < 32; attempt++) {
-    const team = allocateTeamName(taken);
-    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");
-}
 
 export {
   FAMOUS_SOCCER_TEAMS,
@@ -3365,6 +3418,9 @@ export {
   threadDisplayLabel,
   worktreeDisplayLabel,
   worktreeDisplayLabelForGroup,
+  agentNicknameFromWorktreePath,
+  worktreeIdentityTitles,
+  isWorktreeIdentityTitle,
   formatGhLandError,
   githubAgentGitEnv,
   mergeAgentGitAuthEnv,
@@ -3381,6 +3437,8 @@ export {
   getPrStack,
   initPrStack,
   addPrStackLayer,
+  collectTakenTeamSlugs,
+  allocateTeamSlug,
   slugify,
   resolveRepoRoot,
   canonicalizeRepoPath,
@@ -3426,7 +3484,5 @@ export {
   mergePr,
   ghPrCreateAssigneeArgs,
   createOrUpdatePr,
-  suggestSlug,
-  collectTakenTeamSlugs,
-  allocateTeamSlug
+  suggestSlug
 };

package/dist/{chunk-4723RAO3.js → chunk-FWNL62VA.js}

@@ -81,6 +81,7 @@ function normalizeThread(raw) {
     runScriptRequest: normalizeRunScriptRequest(raw.runScriptRequest),
     quotaResumeAt: raw.quotaResumeAt ?? null,
     quotaContinuedFromId: raw.quotaContinuedFromId ?? null,
+    accountId: raw.accountId === null ? null : typeof raw.accountId === "string" && raw.accountId.trim() ? raw.accountId.trim() : void 0,
     archivedAt: typeof raw.archivedAt === "string" && raw.archivedAt.trim() ? raw.archivedAt.trim() : void 0,
     compactedMessages: Array.isArray(raw.compactedMessages) ? raw.compactedMessages : void 0
   };
@@ -133,7 +134,8 @@ function createEmptyThread(partial) {
     repoPath: partial.repoPath,
     agent: partial.agent,
     lastError: null,
-    agentPid: null
+    agentPid: null,
+    ...partial.accountId !== void 0 ? { accountId: partial.accountId } : {}
   };
 }
 async function withThreadLock(id, fn) {