@karpeleslab/teamclaude 1.0.6 → 1.0.7

package/src/alias.js

@@ -0,0 +1,123 @@
+// `claude` shell alias — print or install/uninstall.
+//
+// The alias simply routes plain `claude` through `teamclaude run`, which itself
+// probes the proxy and falls back to launching claude directly when it's down.
+// So the alias stays a dumb passthrough and all the smarts live in `run`.
+//
+// This only affects interactive shells (aliases aren't seen by editors/scripts
+// that exec `claude` themselves). It's intentionally lighter than a PATH shim:
+// no binary shadowing, one line per rc, trivially reversible.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, realpathSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+const MARKER = '# teamclaude alias';
+
+/** Basename of the user's login shell, e.g. "zsh". Defaults to bash. */
+export function detectShell() {
+  return (process.env.SHELL || '').split('/').pop() || 'bash';
+}
+
+/** Whether a bare command resolves on the current $PATH. */
+function commandOnPath(cmd) {
+  for (const dir of (process.env.PATH || '').split(':')) {
+    if (dir && existsSync(join(dir, cmd))) return true;
+  }
+  return false;
+}
+
+/**
+ * How the alias should invoke teamclaude. Prefer the bare `teamclaude` when it's
+ * on $PATH; otherwise embed the absolute path to this CLI (quoted) so the alias
+ * still works when teamclaude isn't installed on PATH — e.g. run from a clone.
+ */
+export function teamclaudeRef() {
+  if (commandOnPath('teamclaude')) return 'teamclaude';
+  const entry = process.argv[1];
+  if (!entry) return 'teamclaude';
+  let abs;
+  try { abs = realpathSync(entry); } catch { abs = entry; }
+  return `"${abs}"`;
+}
+
+/** The alias definition for a given shell family. */
+export function aliasLine(shell = detectShell(), ref = teamclaudeRef()) {
+  const body = `${ref} run --`;
+  if (shell === 'fish') return `alias claude '${body}'`;
+  return `alias claude='${body}'`;
+}
+
+/** The rc file an alias for this shell should live in. */
+export function rcPathForShell(shell = detectShell()) {
+  const home = homedir();
+  switch (shell) {
+    case 'zsh':  return join(home, '.zshrc');
+    case 'sh':   return join(home, '.profile');
+    case 'fish': {
+      const cfg = process.env.XDG_CONFIG_HOME || join(home, '.config');
+      return join(cfg, 'fish', 'conf.d', 'teamclaude.fish');
+    }
+    case 'bash':
+    default:     return join(home, '.bashrc');
+  }
+}
+
+export function printAlias({ shell = detectShell() } = {}) {
+  const line = aliasLine(shell);
+  console.log('# Route plain `claude` through the proxy (when it is running; direct otherwise).');
+  console.log('# Add this to your shell config:');
+  console.log('');
+  console.log(`  ${line}`);
+  console.log('');
+  console.log(`# Or install it automatically: teamclaude alias --install`);
+  console.log(`#   → writes to ${rcPathForShell(shell)} (override with --shell <bash|zsh|fish|sh>)`);
+}
+
+export function installAlias({ shell = detectShell(), rcPath = rcPathForShell(shell) } = {}) {
+  const line = aliasLine(shell);
+  mkdirSync(dirname(rcPath), { recursive: true });
+  let text = existsSync(rcPath) ? readFileSync(rcPath, 'utf8') : '';
+
+  if (text.includes(line)) {
+    console.log(`Alias already present in ${rcPath}`);
+    return;
+  }
+  if (text && !text.endsWith('\n')) text += '\n';
+  text += `${MARKER}\n${line}\n`;
+  writeFileSync(rcPath, text);
+  console.log(`Installed alias in ${rcPath}`);
+  console.log('Reload your shell (or open a new terminal) to use it.');
+}
+
+export function uninstallAlias({ shell = detectShell(), rcPath = rcPathForShell(shell) } = {}) {
+  if (!existsSync(rcPath)) {
+    console.log(`Nothing to remove (${rcPath} does not exist)`);
+    return;
+  }
+  const text = readFileSync(rcPath, 'utf8');
+  // Strip our marked block: the marker comment + the single line after it.
+  // Matching by marker (not by exact alias text) makes this robust even if the
+  // embedded teamclaude path differs from what's computed now.
+  const blockRe = new RegExp(`\\n?${escapeRe(MARKER)}\\n[^\\n]*\\n?`, 'g');
+  let cleaned = text.replace(blockRe, '\n');
+  cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
+
+  if (cleaned === text) {
+    console.log(`Alias not found in ${rcPath}`);
+    return;
+  }
+
+  // For the dedicated fish drop-file, remove it entirely if now empty.
+  if (rcPath.endsWith('teamclaude.fish') && cleaned.trim() === '') {
+    rmSync(rcPath);
+    console.log(`Removed ${rcPath}`);
+    return;
+  }
+  writeFileSync(rcPath, cleaned);
+  console.log(`Removed alias from ${rcPath}`);
+}
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/config.js

@@ -9,6 +9,32 @@ export function getConfigPath() {
   return join(configDir, 'teamclaude.json');
 }
 
+/**
+ * Path to the runtime state file (a sibling of the config). This holds volatile
+ * data learned at runtime — e.g. quota utilization observed passively from
+ * traffic — kept out of the hand-editable config so config stays clean and
+ * isn't rewritten on every state save.
+ */
+export function getStatePath() {
+  const cfg = getConfigPath();
+  return cfg.endsWith('.json') ? cfg.replace(/\.json$/, '.state.json') : cfg + '.state';
+}
+
+export async function loadState() {
+  try {
+    return JSON.parse(await readFile(getStatePath(), 'utf-8'));
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+export async function saveState(state) {
+  const path = getStatePath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+}
+
 export function createDefaultConfig() {
   return {
     proxy: {

package/src/identity.js

@@ -0,0 +1,65 @@
+// Account identity helpers.
+//
+// An OAuth account is identified by its Anthropic account UUID (the *person*)
+// plus the organization it is scoped to. The same email/person can belong to
+// multiple organizations — e.g. a corporate Pro org and a personal Max org —
+// each with its own OAuth token and quota. The org must therefore be part of
+// the identity; otherwise multi-org logins overwrite each other, removals match
+// the wrong entry, and token rotation persists onto the wrong account.
+//
+// The org discriminator prefers the org UUID but falls back to the org name
+// (the profile endpoint has always returned a name), so identity still works on
+// entries created before org UUIDs were stored.
+
+/** Stable org discriminator for an account record: org UUID, else org name, else null. */
+export function orgKey(acct) {
+  return acct?.orgUuid || acct?.orgName || null;
+}
+
+/**
+ * Whether two account records refer to the same account+org.
+ *
+ * - Both have an accountUuid: it must match. If both org keys are known they
+ *   must also match; but if either side's org is still unknown we treat them as
+ *   the same. This lets a freshly-profiled login backfill a legacy entry (which
+ *   has no stored org) instead of creating a duplicate. Once both sides carry an
+ *   org key, a *different* org is correctly seen as a distinct account.
+ * - Otherwise (API-key accounts, or no UUID yet): fall back to matching by name.
+ */
+export function sameIdentity(a, b) {
+  if (a?.accountUuid && b?.accountUuid) {
+    if (a.accountUuid !== b.accountUuid) return false;
+    const ka = orgKey(a);
+    const kb = orgKey(b);
+    if (ka && kb) return ka === kb;
+    return true;
+  }
+  return a?.name === b?.name;
+}
+
+/** The email portion of a display name, stripping any " (org)" suffix. */
+export function emailOf(acct) {
+  return (acct?.name || '').replace(/ \(.*\)$/, '');
+}
+
+/**
+ * Find accounts matching a name-or-email query, optionally narrowed by org.
+ *
+ * An exact display-name match wins outright. Otherwise match by email (so
+ * `remove user@x.com` finds `user@x.com (Acme)`). `orgFilter` narrows by org
+ * name or org UUID (prefix allowed). Returns the array of matches; the caller
+ * decides what to do with 0, 1, or many.
+ */
+export function matchAccounts(accounts, query, orgFilter) {
+  let matches = accounts.filter(a => a.name === query);
+  if (matches.length === 0) {
+    matches = accounts.filter(a => emailOf(a) === query);
+  }
+  if (orgFilter) {
+    matches = matches.filter(a =>
+      (a.orgName && a.orgName === orgFilter) ||
+      (a.orgUuid && (a.orgUuid === orgFilter || a.orgUuid.startsWith(orgFilter)))
+    );
+  }
+  return matches;
+}