@rikcodes/teamclaude 1.1.13-rik.1

package/src/status-renderer.js

@@ -0,0 +1,316 @@
+import { findFamilyBlock, modelGlobOverlaps } from './model.js';
+
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+
+export function renderStatus(status, { color = process.stdout.isTTY, now = Date.now() } = {}) {
+  const paint = colors(color);
+  const lines = [];
+  const probe = status.probe || { enabled: false, intervalSeconds: 0, accounts: [] };
+  const warm = status.warm || { enabled: false, intervalSeconds: 0, accounts: [] };
+  const accounts = status.accounts || [];
+  const blocked = (status.blockedModels || []).filter(p => typeof p === 'string' && p.length);
+
+  lines.push(paint.bold('TeamClaude status'));
+  lines.push(`${paint.dim('Active'.padEnd(12))} ${paint.cyan(status.currentAccount || 'none')}`);
+  lines.push(`${paint.dim('Switch at'.padEnd(12))} ${formatPercent(status.switchThreshold)}`);
+  // Only when something is blocked: a always-visible "Blocked" row would be
+  // noise for the common case, but its ABSENCE is what made a blocked model
+  // read as available — the per-account Models row reports quota headroom and
+  // knows nothing about the blocklist.
+  if (blocked.length) {
+    lines.push(`${paint.dim('Blocked'.padEnd(12))} ${paint.red(blocked.join(', '))}`);
+  }
+  if (status.sessions) {
+    lines.push(`${paint.dim('Sessions'.padEnd(12))} ${formatSessions(status.sessions, paint)}`);
+  }
+  lines.push(`${paint.dim('Probe'.padEnd(12))} ${formatProbeSummary(probe, now, paint)}`);
+  if (warm.enabled) {
+    lines.push(`${paint.dim('Keep-warm'.padEnd(12))} ${formatProbeSummary(warm, now, paint)}`);
+  }
+  if (status.server?.startedAt || status.server?.uptimeSeconds != null) {
+    lines.push(`${paint.dim('Server'.padEnd(12))} ${formatServerSummary(status.server, now)}`);
+  }
+  lines.push('');
+
+  for (const line of routingLines(status.routes, blocked, paint)) lines.push(line);
+
+  for (const account of accounts) {
+    lines.push(renderAccountHeader(account, status.currentAccount, paint, now));
+    for (const quotaLine of quotaLines(account, now, paint)) {
+      lines.push(`  ${quotaLine}`);
+    }
+    const routing = modelRoutingLine(account, status.switchThreshold, blocked, now, paint);
+    if (routing) lines.push(`  ${routing}`);
+    lines.push(`  ${paint.dim('Usage'.padEnd(8))} ${formatUsage(account.usage, now)}`);
+    lines.push(`  ${paint.dim('Probe'.padEnd(8))} ${formatAccountProbe(account.name, probe, now, paint)}`);
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd();
+}
+
+function colors(enabled) {
+  const wrap = code => value => enabled ? `${ESC}${code}m${value}${RESET}` : String(value);
+  return {
+    rgb: (r, g, b, value) => enabled ? `${ESC}38;2;${r};${g};${b}m${value}${RESET}` : String(value),
+    bold: wrap(1),
+    dim: wrap(2),
+    gray: wrap(90),
+    green: wrap(32),
+    yellow: wrap(33),
+    red: wrap(31),
+    blue: wrap(34),
+    magenta: wrap(35),
+    cyan: wrap(36),
+  };
+}
+
+// Paint a route's name/globs in its configured color, defaulting to cyan.
+const ROUTE_COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan'];
+function paintRoute(paint, color, value) {
+  const fn = ROUTE_COLORS.includes(String(color || '').toLowerCase()) ? paint[color.toLowerCase()] : paint.cyan;
+  return fn(value);
+}
+
+// The routing table: one line per route (configured first, then auto-detected),
+// listing the model globs it matches and the accounts it can use, each colored
+// by live eligibility. Auto-created routes (a family metered separately with no
+// configured route) are tagged (auto); a bucket override shows in [brackets].
+function routingLines(routes, blocked, paint) {
+  if (!Array.isArray(routes) || routes.length === 0) return [];
+  const lines = [paint.bold('Routing')];
+  for (const route of routes) {
+    const globs = route.match || [];
+    const match = globs.join(', ');
+    // A route every one of whose globs is blocked can carry no traffic at all —
+    // say so, rather than listing eligible accounts it will never reach.
+    const routeBlocked = globs.length > 0
+      && globs.every(g => blocked.some(p => modelGlobOverlaps(p, g)));
+    const accounts = routeBlocked
+      ? paint.red('blocked')
+      : (route.accounts || [])
+        .map(a => (a.eligible ? paint.green(a.name) : paint.red(a.name))).join(' ') || paint.gray('(none)');
+    const tag = route.autocreated ? paint.dim(' (auto)') : route.bucket ? paint.dim(` [${route.bucket}]`) : '';
+    const pin = route.pinned ? paint.dim(` [pinned: ${route.pinned}]`) : '';
+    // padEnd on the raw text, color after, so ANSI codes don't throw off alignment.
+    const label = paintRoute(paint, route.color, match.padEnd(16));
+    lines.push(`  ${label} ${paint.dim('→')} ${accounts}${tag}${pin}`);
+  }
+  lines.push('');
+  return lines;
+}
+
+function renderAccountHeader(account, currentAccount, paint, now) {
+  const current = account.name === currentAccount;
+  const marker = current ? paint.cyan('>') : ' ';
+  const name = current ? paint.bold(account.name) : account.name;
+  const status = formatAccountStatus(account, now, paint);
+  const org = account.orgName ? ` ${paint.dim(account.orgName)}` : '';
+  const sess = account.sessions ? ` ${paint.dim(`${account.sessions} sess`)}` : '';
+  return `${marker} ${name} ${paint.dim(`(${account.type}, prio ${account.priority || 0})`)} ${status}${org}${sess}`;
+}
+
+// "2 active / 3 known · distributing" — the running-sessions readout.
+function formatSessions(sessions, paint) {
+  const active = sessions.active || 0;
+  const known = sessions.known || 0;
+  const mode = sessions.distribute ? paint.green('distributing') : paint.dim('single-account');
+  return `${active} active / ${known} known ${paint.dim('·')} ${mode}`;
+}
+
+function formatAccountStatus(account, now, paint) {
+  const parts = [];
+  if (account.disabled) parts.push(paint.gray('disabled'));
+
+  const status = account.status || 'unknown';
+  const colored = status === 'active'
+    ? paint.green(status)
+    : status === 'throttled'
+      ? paint.yellow(status)
+      : status === 'error' || status === 'exhausted'
+        ? paint.red(status)
+        : status;
+  parts.push(colored);
+
+  const throttleAt = parseTs(account.rateLimitedUntil);
+  if (throttleAt && throttleAt > now) {
+    parts.push(`throttle ${formatDuration(throttleAt - now)}`);
+  }
+
+  return parts.join(' / ');
+}
+
+// Per-account, per-family eligibility — the "some accounts are disabled for
+// specific models" view. Only rendered for accounts that meter a family
+// separately (a Sonnet or Fable weekly bucket), since that is the only case
+// where a request's model changes where it can route. A family reads ✗ when the
+// shared 5h bucket is spent (blocks everything) or when its own weekly bucket is
+// over the switch threshold; the reset is shown when the family bucket is the
+// blocker so it's clear when that model becomes available on this account again.
+function modelRoutingLine(account, threshold, blocked, now, paint) {
+  const q = account.quota || {};
+  if (q.unified7dSonnet == null && q.unified7dFable == null) return null;
+  const t = Number(threshold);
+  const fiveOver = q.unified5h != null && !Number.isNaN(t) && q.unified5h >= t;
+
+  const cell = (label, weekly, reset) => {
+    // The blocklist outranks quota: a blocked family cannot be served however
+    // much headroom the account has, so it must not read ✓. Reporting quota
+    // alone is what made a fully-blocked model look available.
+    if (findFamilyBlock(blocked, label)) {
+      return `${label} ${paint.red('⊘')}${paint.dim(' blocked')}`;
+    }
+    const weeklyOver = weekly != null && !Number.isNaN(t) && weekly >= t;
+    const mark = fiveOver || weeklyOver ? paint.red('✗') : paint.green('✓');
+    const resetTs = parseTs(reset);
+    const when = weeklyOver && resetTs && resetTs > now ? paint.dim(` ${formatDuration(resetTs - now)}`) : '';
+    return `${label} ${mark}${when}`;
+  };
+
+  const cells = [cell('Opus', q.unified7d, q.unified7dReset)];
+  if (q.unified7dSonnet != null) cells.push(cell('Sonnet', q.unified7dSonnet, q.unified7dSonnetReset));
+  if (q.unified7dFable != null) cells.push(cell('Fable', q.unified7dFable, q.unified7dFableReset));
+  return `${paint.dim('Models'.padEnd(8))} ${cells.join('   ')}`;
+}
+
+function quotaLines(account, now, paint) {
+  const quota = account.quota || {};
+  const lines = [];
+
+  if (quota.unified5h != null || quota.unified7d != null || quota.unified7dSonnet != null || quota.unified7dFable != null) {
+    lines.push(formatQuotaLine('Session', quota.unified5h, quota.unified5hReset, now, paint));
+    lines.push(formatQuotaLine('Weekly', quota.unified7d, quota.unified7dReset, now, paint));
+    if (quota.unified7dSonnet != null) {
+      lines.push(formatQuotaLine('Sonnet', quota.unified7dSonnet, quota.unified7dSonnetReset, now, paint));
+    }
+    if (quota.unified7dFable != null) {
+      lines.push(formatQuotaLine('Fable', quota.unified7dFable, quota.unified7dFableReset, now, paint));
+    }
+    return lines;
+  }
+
+  if (quota.tokensLimit != null && quota.tokensRemaining != null) {
+    const ratio = 1 - quota.tokensRemaining / quota.tokensLimit;
+    lines.push(formatQuotaLine('Tokens', ratio, quota.resetsAt, now, paint));
+  }
+  if (quota.requestsLimit != null && quota.requestsRemaining != null) {
+    const ratio = 1 - quota.requestsRemaining / quota.requestsLimit;
+    lines.push(formatQuotaLine('Requests', ratio, quota.resetsAt, now, paint));
+  }
+  if (lines.length === 0) lines.push(`${paint.dim('Quota'.padEnd(8))} ${paint.gray('unknown')}`);
+  return lines;
+}
+
+function formatQuotaLine(label, ratio, resetAt, now, paint) {
+  const resetTs = parseTs(resetAt);
+  const reset = resetTs && resetTs > now ? ` reset ${formatDuration(resetTs - now)}` : '';
+  return `${paint.dim(label.padEnd(8))} ${usageBar(ratio, paint)} ${formatPercent(ratio)}${reset}`;
+}
+
+function usageBar(ratio, paint) {
+  if (ratio == null || Number.isNaN(Number(ratio))) return `[${paint.gray('??????????????????')}]`;
+  const width = 18;
+  const safeRatio = Math.max(0, Math.min(1, Number(ratio)));
+  const full = Math.round(safeRatio * width);
+  const fill = Array.from({ length: full }, (_, i) => {
+    const [r, g, b] = gradientColor(i, width);
+    return paint.rgb(r, g, b, '█');
+  }).join('');
+  return `[${fill}${paint.gray('░'.repeat(width - full))}]`;
+}
+
+function gradientColor(index, width) {
+  const t = width <= 1 ? 1 : index / (width - 1);
+  const from = t < 0.5 ? [35, 209, 96] : [245, 185, 40];
+  const to = t < 0.5 ? [245, 185, 40] : [239, 68, 68];
+  const p = t < 0.5 ? t * 2 : (t - 0.5) * 2;
+  return from.map((value, i) => Math.round(value + (to[i] - value) * p));
+}
+
+function formatProbeSummary(probe, now, paint) {
+  if (!probe.enabled) return paint.gray('off (passive only)');
+  const bits = [`on every ${formatDuration((probe.intervalSeconds || 0) * 1000)}`];
+  if (probe.running) bits.push(paint.yellow('running'));
+  const last = parseTs(probe.lastRunFinishedAt);
+  if (last) bits.push(`last ${formatAgo(last, now)}`);
+  const next = parseTs(probe.nextRunAt);
+  if (next && next > now) bits.push(`next ${formatDuration(next - now)}`);
+  return bits.join(', ');
+}
+
+function formatAccountProbe(accountName, probe, now, paint) {
+  const row = (probe.accounts || []).find(account => account.name === accountName);
+  if (!probe.enabled) return paint.gray('off');
+  if (!row) return paint.gray('never');
+  if (row.status === 'not-applicable') return paint.gray('not applicable');
+  const status = row.status === 'ok'
+    ? paint.green('ok')
+    : row.status === 'running'
+      ? paint.yellow('running')
+      : row.status === 'never'
+        ? paint.gray('never')
+        : paint.red(row.status || 'error');
+  const last = parseTs(row.lastProbedAt || row.startedAt);
+  const when = last ? ` ${formatAgo(last, now)}` : '';
+  const duration = typeof row.durationMs === 'number' ? `, ${Math.round(row.durationMs)}ms` : '';
+  const error = row.error ? `, ${safeLine(row.error)}` : '';
+  return `${status}${when}${duration}${error}`;
+}
+
+function safeLine(value) {
+  return String(value).replace(/\x1b\[[0-?]*[ -/]*[@-~]|\p{C}/gu, ' ').replace(/\s+/g, ' ').trim().slice(0, 120);
+}
+
+function formatUsage(usage = {}, now) {
+  const requests = usage.totalRequests || 0;
+  const tokens = (usage.totalInputTokens || 0) + (usage.totalOutputTokens || 0);
+  const last = parseTs(usage.lastUsed);
+  const lastText = last ? `, last ${formatAgo(last, now)}` : '';
+  return `${requests} req, ${formatNumber(tokens)} tok${lastText}`;
+}
+
+function formatServerSummary(server, now) {
+  if (server.uptimeSeconds != null) return `up ${formatDuration(server.uptimeSeconds * 1000)}`;
+  const started = parseTs(server.startedAt);
+  return started ? `up ${formatDuration(now - started)}` : 'unknown';
+}
+
+function formatPercent(value) {
+  if (value == null || Number.isNaN(Number(value))) return '-';
+  return `${Math.round(Number(value) * 100)}%`;
+}
+
+function formatNumber(value) {
+  const num = Number(value) || 0;
+  if (num >= 1_000_000) return `${(num / 1_000_000).toFixed(1)}m`;
+  if (num >= 1_000) return `${(num / 1_000).toFixed(1)}k`;
+  return String(num);
+}
+
+function formatAgo(timestamp, now) {
+  const delta = now - timestamp;
+  if (delta < 0) return `in ${formatDuration(-delta)}`;
+  return `${formatDuration(delta)} ago`;
+}
+
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return '-';
+  const totalSeconds = Math.max(1, Math.round(ms / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const totalMinutes = Math.ceil(totalSeconds / 60);
+  if (totalMinutes < 60) return `${totalMinutes}m`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours < 24) return minutes ? `${hours}h${minutes}m` : `${hours}h`;
+  const days = Math.floor(hours / 24);
+  const remHours = hours % 24;
+  return remHours ? `${days}d${remHours}h` : `${days}d`;
+}
+
+function parseTs(value) {
+  if (value == null) return null;
+  if (typeof value === 'number') return value;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}

package/src/sx.js

@@ -0,0 +1,218 @@
+// sx.org proxy integration — an IP-based-429 workaround.
+//
+// teamclaude's transient 429s key on the proxy's OUTBOUND IP, not the account,
+// so account failover doesn't help. sx.org is a residential proxy-port provider:
+// with an API key we provision a port and tunnel upstream Anthropic traffic
+// through it, giving a different egress IP. Crucially, TLS terminates END-TO-END
+// at the upstream (we `tls.connect` over the tunnel with the upstream's
+// servername and the default secure cert check) — the sx.org proxy only ever
+// relays ciphertext and cannot see request content.
+//
+// When no API key is configured (or mode is 'off') this module is dormant and the
+// dial paths behave exactly as before — routing is decided per-attempt by
+// useByDefault() / useOn429() / useForConnect(), all false until provisioned.
+
+import net from 'node:net';
+import tls from 'node:tls';
+
+const CONNECT_TIMEOUT_MS = 30000; // residential exits can be slow to establish
+
+// Resolved per call (not at import) so tests can point it at a local mock.
+const sxBase = () => process.env.SX_API_BASE || 'https://api.sx.org';
+
+// ── sx.org REST (apiKey is a query param; these hit api.sx.org directly, never
+// the proxy, and are unrelated to Anthropic traffic) ──
+async function sxGet(path, apiKey, params = {}) {
+  const url = new URL(sxBase() + path);
+  url.searchParams.set('apiKey', apiKey);
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, String(v));
+  const res = await fetch(url, { headers: { accept: 'application/json' } });
+  return res.json();
+}
+
+async function sxPost(path, apiKey, body) {
+  const url = new URL(sxBase() + path);
+  url.searchParams.set('apiKey', apiKey);
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', accept: 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return res.json();
+}
+
+export const SX_MODES = ['off', '429', 'always'];
+const normalizeMode = (m) => (SX_MODES.includes(m) ? m : 'always');
+
+// Normalize either API shape into { host, port, username, password, portId }.
+//   ports-list:  { proxy: "host:port", login, password, id }
+//   create-port: { server, port, login, password, id }
+function parsePort(p) {
+  let host, port;
+  if (typeof p.proxy === 'string' && p.proxy.includes(':')) {
+    const i = p.proxy.lastIndexOf(':');
+    host = p.proxy.slice(0, i); port = p.proxy.slice(i + 1);
+  } else {
+    host = p.server; port = p.port;
+  }
+  return { host, port: parseInt(port, 10), username: p.login, password: p.password, portId: p.id };
+}
+
+/**
+ * Open a CONNECT tunnel through an HTTP proxy to targetHost:targetPort and
+ * resolve with the raw (still-plaintext) socket once the proxy answers 200.
+ */
+export function connectThroughProxy({ proxyHost, proxyPort, auth, targetHost, targetPort, timeout = CONNECT_TIMEOUT_MS, label = 'sx.org proxy' }) {
+  return new Promise((resolve, reject) => {
+    // autoSelectFamily (happy-eyeballs) — default on Node 20+ but not 18; set it
+    // so a dual-stack proxy host whose IPv6 path is unreachable falls back to IPv4
+    // instead of hanging the connect (sx.org returns an IP, but be robust).
+    const sock = net.connect({ port: proxyPort, host: proxyHost, autoSelectFamily: true });
+    let buf = '';
+    const timer = setTimeout(() => fail(new Error(`${label} CONNECT timed out after ${timeout}ms`)), timeout);
+    const cleanup = () => {
+      clearTimeout(timer);
+      sock.removeListener('data', onData);
+      sock.removeListener('error', fail);
+    };
+    const fail = (err) => { cleanup(); sock.destroy(); reject(err); };
+    const onData = (chunk) => {
+      buf += chunk.toString('latin1');
+      const idx = buf.indexOf('\r\n\r\n');
+      if (idx < 0) { if (buf.length > 65536) fail(new Error(`${label} CONNECT response too large`)); return; }
+      const statusLine = buf.slice(0, buf.indexOf('\r\n'));
+      const m = statusLine.match(/^HTTP\/\d\.\d\s+(\d{3})/);
+      if (!m || m[1] !== '200') { fail(new Error(`${label} refused CONNECT: ${statusLine}`)); return; }
+      cleanup();
+      sock.pause(); // stop flowing so the TLS layer we hand it to sees every byte
+      const rest = Buffer.from(buf.slice(idx + 4), 'latin1'); // bytes already past the header
+      if (rest.length) sock.unshift(rest);
+      resolve(sock);
+    };
+    sock.once('connect', () => {
+      const lines = [`CONNECT ${targetHost}:${targetPort} HTTP/1.1`, `Host: ${targetHost}:${targetPort}`];
+      if (auth) lines.push(`Proxy-Authorization: Basic ${Buffer.from(auth).toString('base64')}`);
+      lines.push('Proxy-Connection: keep-alive', '', '');
+      sock.write(lines.join('\r\n'));
+    });
+    sock.on('data', onData);
+    sock.once('error', fail);
+  });
+}
+
+/**
+ * CONNECT through `proxy`, then complete a TLS handshake to targetHost so TLS is
+ * end-to-end (the proxy sees ciphertext only). Resolves with the TLSSocket after
+ * secureConnect. Cert verification stays at its secure default; tests inject a CA
+ * via tlsOptions.ca.
+ */
+export async function tunnelTls({ proxy, targetHost, targetPort = 443, tlsOptions = {} }) {
+  const sock = await connectThroughProxy({
+    proxyHost: proxy.host,
+    proxyPort: proxy.port,
+    auth: proxy.username ? `${proxy.username}:${proxy.password}` : null,
+    targetHost,
+    targetPort,
+  });
+  return new Promise((resolve, reject) => {
+    const tlsSock = tls.connect({ socket: sock, servername: targetHost, ...tlsOptions });
+    const onErr = (err) => { tlsSock.removeListener('secureConnect', onOk); sock.destroy(); reject(err); };
+    const onOk = () => { tlsSock.removeListener('error', onErr); resolve(tlsSock); };
+    tlsSock.once('secureConnect', onOk);
+    tlsSock.once('error', onErr);
+  });
+}
+
+/**
+ * Holds the sx.org credential + the provisioned proxy. Shared in-process by the
+ * reverse proxy, the MITM handler, and the TUI so a key change applies live.
+ */
+export class SxManager {
+  constructor({ log = () => {} } = {}) {
+    this.log = log;
+    this.apiKey = null;
+    this.proxy = null;   // { host, port, username, password, portId }
+    this.mode = 'always'; // off | 429 | always — how routing decisions are made
+    this._rlUntil = 0;    // sticky-routing window end (ms) for '429' mode
+  }
+
+  isProvisioned() { return !!(this.apiKey && this.proxy); }
+  getProxy() { return this.proxy; }
+  getMode() { return this.mode; }
+
+  // ── routing decisions ──
+  // Reverse-proxy first attempt: only 'always' routes pre-emptively.
+  useByDefault() { return this.isProvisioned() && this.mode === 'always'; }
+  // Reverse-proxy retry after a 429: 'always' and '429' both route (the 429 is
+  // IP-based, so a fresh egress IP can clear it).
+  useOn429() { return this.isProvisioned() && this.mode !== 'off'; }
+  // MITM connect-time (one tunnel carries many requests, so no per-request
+  // failover): 'always' routes; '429' routes only inside the sticky window set
+  // when a 429 was recently observed.
+  useForConnect() {
+    if (!this.isProvisioned() || this.mode === 'off') return false;
+    return this.mode === 'always' || this.isRecentlyRateLimited();
+  }
+
+  noteRateLimited(seconds = 60) { this._rlUntil = Date.now() + Math.min(Math.max(seconds, 1), 300) * 1000; }
+  isRecentlyRateLimited() { return Date.now() < this._rlUntil; }
+
+  /** Set the API key (+ optional mode) and provision unless mode is 'off'. */
+  async configure(apiKey, mode = this.mode) {
+    this.mode = normalizeMode(mode);
+    if (!apiKey) { this.disable(); return { ok: false, error: 'no API key' }; }
+    this.apiKey = apiKey;
+    if (this.mode === 'off') { this.proxy = null; return { ok: true, mode: this.mode, proxy: null }; }
+    return this._ensureProxy();
+  }
+
+  /** Switch mode WITHOUT clearing the key; provision lazily when turning on. */
+  async setMode(mode) {
+    this.mode = normalizeMode(mode);
+    if (this.mode === 'off') { this.proxy = null; return { ok: true, mode: this.mode }; }
+    if (this.apiKey && !this.proxy) return this._ensureProxy();
+    return { ok: true, mode: this.mode, proxy: this.proxy };
+  }
+
+  /** Full deconfigure — forget the key entirely. */
+  disable() { this.apiKey = null; this.proxy = null; }
+
+  async _ensureProxy() {
+    try {
+      this.proxy = await this.provision();
+      this.log(`[TeamClaude] sx.org proxy ready: ${this.proxy.host}:${this.proxy.port}`);
+      return { ok: true, mode: this.mode, proxy: this.proxy };
+    } catch (err) {
+      this.proxy = null;
+      this.log(`[TeamClaude] sx.org provisioning failed: ${err.message}`);
+      return { ok: false, error: err.message };
+    }
+  }
+
+  /** Account balance/traffic, or null on error. */
+  async getBalance() {
+    if (!this.apiKey) return null;
+    try {
+      const r = await sxGet('/v2/user/balance', this.apiKey);
+      return r?.success ? r : null;
+    } catch { return null; }
+  }
+
+  /** Reuse an active port if one exists, else create a residential US one. */
+  async provision() {
+    if (!this.apiKey) throw new Error('sx.org API key not set');
+    const list = await sxGet('/v2/proxy/ports', this.apiKey, { per_page: 50 });
+    const proxies = list?.message?.proxies || [];
+    const active = proxies.find((p) => p.status === 1 && p.login && p.password && p.proxy);
+    if (active) return parsePort(active);
+
+    const created = await sxPost('/v2/proxy/create-port', this.apiKey, {
+      country_code: 'US', proxy_type_id: 1, type_id: 1, // type_id 1 = residential
+    });
+    if (!created?.success || !created.data) {
+      const detail = created?.errors ? JSON.stringify(created.errors) : (created?.message || JSON.stringify(created));
+      throw new Error(`sx.org create-port failed: ${detail}`);
+    }
+    return parsePort(created.data);
+  }
+}

package/src/terminal-title.js

@@ -0,0 +1,31 @@
+// Reflect the active account in the terminal title (e.g. "teamclaude 2/4 work"),
+// so a backgrounded or tabbed `teamclaude server` is glanceable without
+// switching to it. Pure/side-effect-free here so it can be unit-tested; the
+// caller owns the TTY gate and the interval.
+
+const OSC_TITLE = '\x1b]0;'; // OSC 0 — set icon name + window title
+const BEL = '\x07';
+
+// xterm title stack: save the shell's current title on start and restore it on
+// exit. No-op on terminals that don't implement it.
+export const TITLE_STACK_PUSH = '\x1b[22;2t';
+export const TITLE_STACK_POP = '\x1b[23;2t';
+
+function truncate(s, max) {
+  s = String(s);
+  return s.length <= max ? s : `${s.slice(0, max - 1)}…`;
+}
+
+// Short, glanceable title: "teamclaude <pos>/<total> <name>". `index` is 0-based.
+export function formatTerminalTitle({ index = 0, total = 0, name = null } = {}) {
+  const pos = total > 0 ? `${index + 1}/${total}` : '0/0';
+  const who = name ? ` ${truncate(name, 24)}` : '';
+  return `teamclaude ${pos}${who}`;
+}
+
+// Wrap a title string in the OSC set-title sequence, stripping control chars so a
+// crafted account name can't break out of the escape or move the cursor.
+export function titleSequence(title) {
+  const safe = String(title).replace(/[\x00-\x1f\x7f]/g, ' ').trimEnd();
+  return `${OSC_TITLE}${safe}${BEL}`;
+}