bullswarm 0.14.1 → 0.15.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # bullswarm changelog
 
+## 0.15.0 — extra Claude Code logins as separate pools
+
+- Claude Code extra logins (`~/.claude-<slug>` / `$CLAUDE_CONFIG_DIR`) become
+  their own pools (`claude-code:<slug>`), metered and spawned with
+  `CLAUDE_CONFIG_DIR` set. Discovery is dynamic from the filesystem; there
+  is no hardcoded extra-profile list. The spawn command for each profile is
+  `CLAUDE_CONFIG_DIR=<dir> claude`.
+
 ## 0.14.1 — the TUI survives its writer; steering lands or expires truthfully
 
 Proven on a goal-3 re-run (`d7xyg2`): 1 planner turn / 269 s (baseline 0.13.1: 1 / 294 s), planner context 6.2 k chars (from 32.7 k), auto-completed, deliverable verified, zero observation crashes — `docs/experiments/2026-08-29-dogfood-bullswarm-builds-bullswarm.md`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bullswarm",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "Route work across coding-agent CLI subscriptions — paced by live quota meters, verified by content, never trusting exit codes.",
   "type": "module",
   "bin": {

package/src/lib/claude-accounts.js

@@ -0,0 +1,202 @@
+// Discover Claude Code logins on this machine.
+//
+// One account = one config dir (`~/.claude` by default, or CLAUDE_CONFIG_DIR).
+// Extra homes live next to it as `~/.claude-<slug>`. Credentials:
+//   macOS Keychain `Claude Code-credentials` for ~/.claude
+//   `Claude Code-credentials-<sha256(absPath)[:8]>` for any other home
+//   plus `$dir/.credentials.json` on every platform.
+
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import {
+  DEFAULT_KEYCHAIN_SERVICE,
+  extractCredentials,
+  isUsable,
+  readFromMacKeychain,
+} from '../meters/claude.js';
+
+const HOME_MARKERS = ['.credentials.json', '.claude.json', 'settings.json', 'projects'];
+
+export function defaultClaudeHome(homeDir = homedir()) {
+  return resolve(join(homeDir, '.claude'));
+}
+
+export function keychainServiceForConfigDir(configDir, homeDir = homedir()) {
+  const resolved = resolve(configDir);
+  if (resolved === defaultClaudeHome(homeDir)) return DEFAULT_KEYCHAIN_SERVICE;
+  const hash = createHash('sha256').update(resolved).digest('hex').slice(0, 8);
+  return `${DEFAULT_KEYCHAIN_SERVICE}-${hash}`;
+}
+
+export function accountSlugForConfigDir(configDir, homeDir = homedir()) {
+  const resolved = resolve(configDir);
+  if (resolved === defaultClaudeHome(homeDir)) return null;
+  const base = basename(resolved);
+  if (base.startsWith('.claude-')) {
+    const slug = base.slice('.claude-'.length);
+    return slug.length > 0 ? slug : 'alt';
+  }
+  if (base.startsWith('.claude')) {
+    const rest = base.slice('.claude'.length).replace(/^-+/, '');
+    return rest.length > 0 ? rest : 'alt';
+  }
+  return base || 'alt';
+}
+
+export function poolNameForSlug(slug) {
+  return slug ? `claude-code:${slug}` : 'claude-code';
+}
+
+export function looksLikeClaudeHome(dir) {
+  try {
+    if (!statSync(dir).isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  return HOME_MARKERS.some((name) => existsSync(join(dir, name)));
+}
+
+export function discoverClaudeConfigDirs(opts = {}) {
+  const homeDir = opts.homeDir ?? homedir();
+  const found = [];
+  const seen = new Set();
+  const add = (dir) => {
+    const resolved = resolve(dir);
+    if (seen.has(resolved)) return;
+    if (!looksLikeClaudeHome(resolved)) return;
+    seen.add(resolved);
+    found.push(resolved);
+  };
+  add(join(homeDir, '.claude'));
+  try {
+    for (const name of readdirSync(homeDir)) {
+      if (!name.startsWith('.claude-')) continue;
+      add(join(homeDir, name));
+    }
+  } catch { /* unreadable home */ }
+  const envDir = opts.envConfigDir ?? process.env.CLAUDE_CONFIG_DIR;
+  if (envDir && String(envDir).trim()) add(String(envDir).trim());
+  return found;
+}
+
+function readCredentialsFile(path) {
+  try {
+    return extractCredentials(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function readAccountCredentials(configDir, opts = {}) {
+  const homeDir = opts.homeDir ?? homedir();
+  const nowMs = opts.nowMs ?? Date.now();
+  const os = opts.platform ?? platform();
+  const keychainRead = opts.readKeychain ?? readFromMacKeychain;
+  const usableOnly = opts.usableOnly !== false;
+
+  const fileCreds = readCredentialsFile(join(configDir, '.credentials.json'));
+  let keychainCreds = null;
+  if (os === 'darwin') {
+    keychainCreds = keychainRead(keychainServiceForConfigDir(configDir, homeDir));
+  }
+  const extraFile = resolve(configDir) === defaultClaudeHome(homeDir)
+    ? readCredentialsFile(join(homeDir, '.config', 'claude', 'credentials.json'))
+    : null;
+
+  const candidates = [];
+  if (keychainCreds) candidates.push({ creds: keychainCreds, source: 'keychain' });
+  if (fileCreds) candidates.push({ creds: fileCreds, source: 'file' });
+  if (extraFile) candidates.push({ creds: extraFile, source: 'file' });
+  for (const c of candidates) {
+    if (!usableOnly || isUsable(c.creds, nowMs)) return c;
+  }
+  return null;
+}
+
+export function profileCommand(configDir, bin = 'claude') {
+  return `CLAUDE_CONFIG_DIR=${configDir} ${bin}`;
+}
+
+export function discoverClaudeAccounts(opts = {}) {
+  const homeDir = opts.homeDir ?? homedir();
+  const dirs = discoverClaudeConfigDirs({
+    homeDir,
+    envConfigDir: opts.envConfigDir,
+  });
+  const accounts = [];
+  const seenTokens = new Set();
+  for (const configDir of dirs) {
+    const got = readAccountCredentials(configDir, opts);
+    if (!got) continue;
+    if (seenTokens.has(got.creds.accessToken)) continue;
+    seenTokens.add(got.creds.accessToken);
+    const slug = accountSlugForConfigDir(configDir, homeDir);
+    accounts.push({
+      configDir,
+      slug,
+      pool: poolNameForSlug(slug),
+      command: profileCommand(configDir, opts.bin ?? 'claude'),
+      creds: got.creds,
+      source: got.source,
+    });
+  }
+  accounts.sort((a, b) => {
+    if (a.slug === null) return -1;
+    if (b.slug === null) return 1;
+    return a.slug.localeCompare(b.slug);
+  });
+  return accounts;
+}
+
+/**
+ * Clone the packaged `claude-code` connector once per extra login.
+ * The default home keeps the historical pool name `claude-code`.
+ * Extra homes become `claude-code:<slug>` with CLAUDE_CONFIG_DIR in env
+ * so spawn bills that seat. Discovery is filesystem-driven — never a
+ * hardcoded profile list.
+ */
+export function expandClaudeAccountConnectors(connectors, opts = {}) {
+  if (opts.disabled === true) return connectors;
+  if (process.env.BULLSWARM_DISABLE_CLAUDE_PROFILES === '1') return connectors;
+  // node:test (and MCP children it spawns) inherit NODE_TEST_CONTEXT. Do not
+  // scan the operator's real extra Claude homes unless the test injects
+  // `accounts` or `homeDir`.
+  if (process.env.NODE_TEST_CONTEXT && opts.accounts == null && opts.homeDir == null) {
+    return connectors;
+  }
+  const base = connectors['claude-code'];
+  if (!base) return connectors;
+  const accounts = opts.accounts ?? discoverClaudeAccounts({
+    homeDir: opts.homeDir,
+    envConfigDir: opts.envConfigDir,
+    bin: base.bin ?? 'claude',
+  });
+  const defaultDir = accounts.find((a) => a.slug == null)?.configDir
+    ?? defaultClaudeHome(opts.homeDir);
+  const bin = base.bin ?? 'claude';
+  base.env = { ...(base.env ?? {}), CLAUDE_CONFIG_DIR: defaultDir };
+  base.profile = {
+    slug: null,
+    configDir: defaultDir,
+    command: profileCommand(defaultDir, bin),
+  };
+  for (const account of accounts) {
+    if (!account.slug) continue;
+    const name = account.pool;
+    if (connectors[name]) continue;
+    const clone = structuredClone(base);
+    clone.name = name;
+    clone.env = { ...(base.env ?? {}), CLAUDE_CONFIG_DIR: account.configDir };
+    clone.configDirs = [account.configDir];
+    clone.flags = { ...(base.flags ?? {}), isCaller: false };
+    clone.profile = {
+      slug: account.slug,
+      configDir: account.configDir,
+      command: account.command,
+    };
+    connectors[name] = clone;
+  }
+  return connectors;
+}

package/src/lib/config.js

@@ -13,8 +13,9 @@ import { readFileSync, readdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { loadState } from './state.js';
 import { paceScore, isQuarantined } from './route.js';
+import { expandClaudeAccountConnectors } from './claude-accounts.js';
 
-export function loadConnectors(bullswarmDir) {
+export function loadConnectors(bullswarmDir, opts = {}) {
   const dir = join(bullswarmDir, 'connectors');
   if (!existsSync(dir)) return {};
   const out = {};
@@ -28,6 +29,7 @@ export function loadConnectors(bullswarmDir) {
       // never crash a run
     }
   }
+  expandClaudeAccountConnectors(out, opts);
   return out;
 }
 

package/src/lib/watch.js

@@ -78,7 +78,12 @@ export function runDelegate(connector, taskFile, targetDir, opts = {}) {
       // hazard). Caller-supplied opts.env takes precedence over
       // process.env so the runtime can inject BULLSWARM_DEPTH (recursion
       // guard) and other core-owned env contracts.
-      env: { ...process.env, ...(opts.env ?? {}), PWD: resolvedDir },
+      env: {
+        ...process.env,
+        ...(connector.env ?? {}),
+        ...(opts.env ?? {}),
+        PWD: resolvedDir,
+      },
       stdio: ['ignore', 'pipe', 'pipe'],
     });
     opts.onSpawn?.(child.pid);

package/src/meters/claude.js

@@ -19,18 +19,24 @@ export class ClaudeMeterError extends Error {
   }
 }
 
+export const DEFAULT_KEYCHAIN_SERVICE = 'Claude Code-credentials';
+
+export function isUsable(creds, now = Date.now(), skewMs = EXPIRY_SKEW_MS) {
+  return Boolean(creds) && creds.expiresAt - skewMs > now;
+}
+
 export function readOAuthCredentials() {
   if (platform() === 'darwin') {
-    return readFromMacKeychain() ?? readFromCredentialsFile();
+    return readFromMacKeychain(DEFAULT_KEYCHAIN_SERVICE) ?? readFromCredentialsFile();
   }
   return readFromCredentialsFile();
 }
 
-function readFromMacKeychain() {
+export function readFromMacKeychain(service = DEFAULT_KEYCHAIN_SERVICE) {
   try {
     const blob = execFileSync(
       'security',
-      ['find-generic-password', '-s', 'Claude Code-credentials', '-w'],
+      ['find-generic-password', '-s', service, '-w'],
       { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' },
     );
     return extractCredentials(blob);
@@ -73,13 +79,13 @@ function normalizeWindow(raw) {
   };
 }
 
-export function parseClaudeUsage(body) {
+export function parseClaudeUsage(body, pool = 'claude-code') {
   if (!body || typeof body !== 'object') {
     throw new ClaudeMeterError('Claude usage response missing body', 'parse');
   }
   return {
     captured_at: new Date().toISOString(),
-    pool: 'claude-code',
+    pool,
     five_hour: normalizeWindow(body.five_hour) ?? { utilization: null, resets_at: null },
     seven_day: normalizeWindow(body.seven_day) ?? { utilization: null, resets_at: null },
     monthly: null,
@@ -89,12 +95,11 @@ export function parseClaudeUsage(body) {
   };
 }
 
-export async function fetchClaudeUsage() {
-  const creds = readOAuthCredentials();
+export async function fetchClaudeUsageWithCredentials(creds, pool = 'claude-code') {
   if (!creds) {
     throw new ClaudeMeterError('No Claude Code OAuth token. Run `claude` to log in.', 'no_token');
   }
-  if (creds.expiresAt - EXPIRY_SKEW_MS <= Date.now()) {
+  if (!isUsable(creds)) {
     throw new ClaudeMeterError(
       'Claude OAuth token expired; open Claude Code to refresh it.',
       'expired',
@@ -122,5 +127,9 @@ export async function fetchClaudeUsage() {
   } catch (err) {
     throw new ClaudeMeterError(`Failed to parse usage response: ${err.message}`, 'parse');
   }
-  return parseClaudeUsage(body);
+  return parseClaudeUsage(body, pool);
+}
+
+export async function fetchClaudeUsage() {
+  return fetchClaudeUsageWithCredentials(readOAuthCredentials(), 'claude-code');
 }

package/src/meters/registry.js

@@ -6,7 +6,8 @@ import { MeterCache, paceSnapshot, FRESH_MS, STALE_MS } from './framework.js';
 import { fetchCodexUsage, CodexMeterError } from './codex.js';
 import { fetchGrokUsage, GrokMeterError } from './grok.js';
 import { fetchCommandCodeUsage, CommandCodeMeterError } from './command-code.js';
-import { fetchClaudeUsage, ClaudeMeterError } from './claude.js';
+import { fetchClaudeUsage, fetchClaudeUsageWithCredentials, ClaudeMeterError } from './claude.js';
+import { discoverClaudeAccounts, poolNameForSlug } from '../lib/claude-accounts.js';
 
 export const METERS_DIR = () =>
   process.env.BULLSWARM_HOME?.trim() || join(homedir(), '.bullswarm');
@@ -19,7 +20,26 @@ const READERS = {
   claude: fetchClaudeUsage,
 };
 
+function claudeReaderFor(pool) {
+  return async () => {
+    const accounts = discoverClaudeAccounts();
+    const slug = pool.startsWith('claude-code:') ? pool.slice('claude-code:'.length) : null;
+    const account = accounts.find((a) => poolNameForSlug(a.slug) === pool)
+      ?? accounts.find((a) => a.slug === slug);
+    if (!account) {
+      throw new ClaudeMeterError(
+        `No Claude Code OAuth token for pool ${pool}. Log in with CLAUDE_CONFIG_DIR pointing at that home.`,
+        'no_token',
+      );
+    }
+    return fetchClaudeUsageWithCredentials(account.creds, pool);
+  };
+}
+
 export function readerFor(pool) {
+  if (pool === 'claude-code' || pool === 'claude' || pool.startsWith('claude-code:')) {
+    return claudeReaderFor(pool);
+  }
   return READERS[pool] ?? null;
 }
 

package/src/workflow/cli.js

@@ -457,6 +457,8 @@ async function wfCapabilities(opts) {
       enabled: p.enabled !== false,
       lanes: p.lanes ?? p.connector?.lanes ?? [],
       capabilities: p.capabilities ?? p.connector?.capabilities ?? [],
+      command: p.connector?.profile?.command ?? p.connector?.spawn?.cmd?.[0] ?? null,
+      configDir: p.connector?.profile?.configDir ?? p.connector?.env?.CLAUDE_CONFIG_DIR ?? null,
       model: (() => {
         const cmd = p.connector?.spawn?.cmd ?? [];
         const i = cmd.indexOf('--model');