claude-org 0.1.0 → 0.2.2

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 
-## 0.1.0 (unreleased)
+## Unreleased
+
+## 0.2.2 — 2026-10-10
+
+- Development: `npm run release -- <patch|minor|major|X.Y.Z>` runs the whole release (checks, tests, CHANGELOG, version, commit, tag, push, npm publish, registry check)
+
+## 0.2.1 — 2026-10-10
+
+- `proxy`: a 429 is now classified before failing over (#8). Only a rejected 5h or 7d window takes the whole org out. Any other 429 (a used-up per-model allowance, a model that needs usage credits, a per-minute limit) takes the org out for that model only, for at most 10 minutes or the `retry-after` time, so other models keep using the org
+- `proxy`: the log now shows the reason of each 429 (`error.type: message`, decoded from a brotli/gzip/deflate body) and the rate-limit claim, and says to switch the model when every org refused the same model
+- Windows: launch `claude` without the Node DEP0190 deprecation warning (shell args passed as one quoted command string) (#10)
+
+## 0.2.0 — 2026-10-03
+
+- Add `ccorg` as a short command alias for `claude-org` (same binary)
+- Docs: clarify Setup (org picker, token is printed and saved manually, repeat once per org); example labels are `work` / `personal` and explicitly arbitrary
+
+## 0.1.0 — 2026-10-03
 
 Initial public release.
 

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 miyashita337
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 miyashita337
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,7 +2,7 @@
 
 Launch [Claude Code](https://code.claude.com) under a specific Anthropic **organization** — and keep running when the 5-hour usage limit hits, by failing over to another org you belong to.
 
-When one account has multiple Claude organizations (e.g. a personal Pro/Max org and a company Team org), hitting the usage limit stalls your session. `claude-org` switches the credential `claude` starts with, and — in `proxy` mode — swaps it **mid-session** the moment the limit hits, so a long-running task never stops.
+When one account has multiple Claude organizations (e.g. a personal org and your company's org, or several personal orgs), hitting the usage limit stalls your session. `claude-org` switches the credential `claude` starts with, and — in `proxy` mode — swaps it **mid-session** the moment the limit hits, so a long-running task never stops.
 
 Requires Node.js 18+. Zero runtime dependencies. Works on Windows, macOS, and Linux.
 
@@ -12,31 +12,43 @@ Requires Node.js 18+. Zero runtime dependencies. Works on Windows, macOS, and Li
 npm install -g claude-org
 ```
 
+This installs two commands that behave identically: `claude-org` and the shorter alias `ccorg`. Examples below use `claude-org`; substitute `ccorg` anywhere.
+
 ## Setup
 
-1. Generate a long-lived token per org (valid ~1 year):
+Each org you want to switch between needs its own long-lived token, saved under a label you choose. The plain `claude` login (no token file) is called the **default org** and needs no setup.
+
+Repeat steps 1–2 **once per org**:
+
+1. Generate a token for one org (valid ~1 year):
 
    ```sh
    claude setup-token
    ```
 
-   In the browser, pick the org you want the token for, approve, and paste the auth code back into the terminal.
+   A browser opens. If your account belongs to several orgs, an **org picker** appears — choose the org this token is for. Approve, paste the auth code back into the terminal, and `claude setup-token` **prints the token to stdout**. It does not save it anywhere; you save it in the next step.
 
-2. Save each token (no trailing newline) as `~/.claude/org-tokens/<name>.token` (`<name>` is your label, e.g. `team`):
+2. Save that token (no trailing newline) as `~/.claude/org-tokens/<name>.token`. `<name>` is just a label you pick — it does not need to match the org's plan or display name. `work` and `personal` are common; `client-a`, `personal2`, etc. are equally fine.
 
    ```sh
    # bash / macOS / Linux
    mkdir -p ~/.claude/org-tokens
-   printf '%s' '<token>' > ~/.claude/org-tokens/team.token
+   printf '%s' '<token>' > ~/.claude/org-tokens/work.token
    ```
 
    ```powershell
    # PowerShell
    New-Item -ItemType Directory -Force "$env:USERPROFILE\.claude\org-tokens" | Out-Null
-   Set-Content -NoNewline "$env:USERPROFILE\.claude\org-tokens\team.token" "<token>"
+   Set-Content -NoNewline "$env:USERPROFILE\.claude\org-tokens\work.token" "<token>"
    ```
 
-   The plain `claude` login (no env) is called the **default org** and needs no token file. Note the token may visually wrap to two lines in the terminal — join it into one.
+   The token may visually wrap onto two lines in the terminal — join it into one.
+
+3. Check that each label points at the org you intended:
+
+   ```sh
+   claude-org status
+   ```
 
 ## Commands
 
@@ -44,7 +56,7 @@ npm install -g claude-org
 |---|---|
 | `claude-org proxy [claude args...]` | Launch via a local proxy: a **running** session fails over to another org the moment the 5h limit hits. Needs 2+ org tokens (incl. one for the default side). |
 | `claude-org auto [claude args...]` | Launch on the preferred org if usable, else on the default org. Decided once at launch. |
-| `claude-org <name> [claude args...]` | Launch with that org's token, e.g. `claude-org team --resume`. |
+| `claude-org <name> [claude args...]` | Launch with that org's token, e.g. `claude-org work --resume`. |
 | `claude-org probe [<name>]` | Print the org's 5h window state on one line (`status= 5h_util= 5h_reset= 5h_reset_local=`). Exit 0 when `allowed`. |
 | `claude-org watch` | Poll the preferred org until its window recovers, then notify (terminal + optional `CLAUDE_ORG_NOTIFY_CMD`). |
 | `claude-org status` | `claude auth status` for every saved token + the default login. |
@@ -118,6 +130,20 @@ npm test            # node:test suite, no real API calls
 npm pack --dry-run  # inspect the published file set
 ```
 
+### Releasing
+
+Write the changes under `## Unreleased` in `CHANGELOG.md`, then on an up-to-date `main`:
+
+```sh
+npm login                               # once per machine
+npm run release -- patch --dry-run      # checks + tests only, changes nothing
+npm run release -- patch                # or minor / major / X.Y.Z
+```
+
+The script refuses to run off `main`, with uncommitted tracked changes, out of sync with `origin/main`, with an existing tag or registry version, with files npm would publish that git does not track, or without npm login. It then runs the tests, renames `## Unreleased` to the new version heading, bumps `package.json`, commits `chore: release vX.Y.Z`, tags, pushes the commit and tag together (atomic), runs `npm publish` and waits until the registry serves the new version. `--no-publish` stops after the push.
+
+Users update with `npm install -g claude-org@latest`.
+
 ## License
 
 MIT

package/lib/claude-spawn.js

@@ -0,0 +1,16 @@
+'use strict';
+const { spawn } = require('child_process');
+
+// DEP0190: passing an args array with shell:true is deprecated (args are
+// concatenated unescaped). On Windows a shell is still needed to resolve
+// claude.cmd, so build a single quoted command string instead.
+const q = s => `"${String(s).replace(/(["\\$`])/g, '\\$1')}"`;
+
+function spawnClaude(args, opts = {}) {
+  if (process.platform === 'win32') {
+    return spawn(['claude', ...args.map(q)].join(' '), { ...opts, shell: true });
+  }
+  return spawn('claude', args, opts);
+}
+
+module.exports = { spawnClaude, q };

package/lib/launch.js

@@ -1,14 +1,13 @@
 'use strict';
-const { spawn } = require('child_process');
+const { spawnClaude } = require('./claude-spawn');
 const { readToken } = require('./config');
 
 // Spawn claude with inherited stdio and extra env. Resolves to the child's
 // exit code (128+n when killed by signal n, like a shell would report).
 function runClaude(args, envExtra = {}) {
   return new Promise(resolve => {
-    const child = spawn('claude', args, {
+    const child = spawnClaude(args, {
       stdio: 'inherit',
-      shell: process.platform === 'win32', // resolves claude.cmd on Windows
       env: { ...process.env, ...envExtra },
     });
     child.on('error', e => {

package/lib/proxy.js

@@ -6,6 +6,12 @@
 // with the next org's token. A running Claude Code session never sees the 429,
 // so the org switches without a restart.
 //
+// Not every 429 means the org is used up. A model can have its own limit (for
+// example a per-model weekly allowance, or usage credits that the org has not
+// enabled) while the 5h and 7d windows are still "allowed" and other models
+// work. Such a 429 only takes that org out for that model; the org keeps
+// serving other models.
+//
 // Why a proxy instead of apiKeyHelper: an OAuth long-lived token is accepted as
 // `Authorization: Bearer` alone, but if `x-api-key` is also present it is checked
 // first and returns 401. The proxy drops x-api-key and sends Bearer only.
@@ -23,6 +29,88 @@ const https = require('https');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const zlib = require('zlib');
+
+// How long an org stays out when it is org-wide limited but sent no reset time,
+// and the longest a model-specific refusal keeps an (org, model) pair out.
+const ORG_REJECT_FALLBACK_MS = 10 * 60 * 1000;
+const MODEL_REJECT_MAX_MS = 10 * 60 * 1000;
+// A real 429 body is well under 1 KiB. These caps keep a misbehaving upstream
+// from exhausting memory: the raw body read, and the decompressed copy.
+const ERROR_BODY_MAX_BYTES = 1024 * 1024;
+const ERROR_DECODED_MAX_BYTES = 64 * 1024;
+
+// The "model" field of a /v1/messages request body, or '?' when the body is
+// not JSON (the proxy must still forward it). Used as is as the quarantine
+// key, so two different model names never share a key.
+function requestModel(body) {
+  try {
+    const m = JSON.parse(body.toString('utf8')).model;
+    return typeof m === 'string' && m ? m : '?';
+  } catch {
+    return '?';
+  }
+}
+
+// The model name for the log: client input, so limited to safe characters and
+// cut short.
+function logModel(model) {
+  return model.replace(/[^\w.:@/-]/g, '_').slice(0, 80);
+}
+
+// Milliseconds from a Retry-After header, which is either delay-seconds or an
+// HTTP-date. NaN when absent or unparsable.
+function retryAfterMs(value) {
+  if (value === undefined || value === '') return NaN;
+  const secs = Number(value);
+  if (Number.isFinite(secs)) return secs >= 0 ? secs * 1000 : NaN;
+  const at = Date.parse(value);
+  return Number.isFinite(at) ? Math.max(0, at - Date.now()) : NaN;
+}
+
+function readBody(res, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    res.on('data', c => {
+      size += c.length;
+      if (size > maxBytes) {
+        res.destroy();
+        reject(new Error(`429 body larger than ${maxBytes} bytes`));
+        return;
+      }
+      chunks.push(c);
+    });
+    res.on('end', () => resolve(Buffer.concat(chunks)));
+    res.on('error', reject);
+  });
+}
+
+// The API compresses error bodies (brotli was observed on 2026-10-10) when the
+// client sent accept-encoding. Decode a copy for the log; the client still
+// gets the original bytes with the original content-encoding header.
+// maxOutputLength makes a decompression bomb throw instead of filling memory.
+function decodeBody(buf, encoding) {
+  const opts = { maxOutputLength: ERROR_DECODED_MAX_BYTES };
+  switch ((encoding || '').trim().toLowerCase()) {
+    case 'br': return zlib.brotliDecompressSync(buf, opts);
+    case 'gzip': case 'x-gzip': return zlib.gunzipSync(buf, opts);
+    case 'deflate': return zlib.inflateSync(buf, opts);
+    default: return buf;
+  }
+}
+
+// "error.type: error.message" from an API error body, for the log line. The
+// message is cut short; the full body still reaches the client.
+function describeError(buf, encoding) {
+  try {
+    const e = JSON.parse(decodeBody(buf, encoding).toString('utf8')).error || {};
+    const msg = String(e.message || '').replace(/\s+/g, ' ').slice(0, 160);
+    return msg ? `${e.type || 'unknown_error'}: ${msg}` : (e.type || 'unknown_error');
+  } catch {
+    return 'non-JSON 429 body';
+  }
+}
 
 function createProxy(opts = {}) {
   const TOKEN_DIR = opts.tokenDir || process.env.CLAUDE_ORG_TOKEN_DIR
@@ -59,6 +147,15 @@ function createProxy(opts = {}) {
       return false;
     }
   }
+  // Per-(org, model) memory for model-specific refusals: "org|model" -> epoch (ms).
+  const modelRejectedUntil = new Map();
+  function isModelRejected(name, model) {
+    const key = `${name}|${model}`;
+    const until = modelRejectedUntil.get(key);
+    if (until === undefined) return false;
+    if (Date.now() >= until) { modelRejectedUntil.delete(key); return false; }
+    return true;
+  }
   function isRejected(name) {
     if (fileRejected(name)) return true;
     const until = rejectedUntil.get(name);
@@ -68,9 +165,10 @@ function createProxy(opts = {}) {
   }
   // Usable orgs first, in priority order; rate-limited orgs are moved to the
   // tail (kept as a last resort when everything is limited).
-  function pickOrder() {
+  function pickOrder(model) {
     const orgs = listOrgs();
-    return orgs.filter(o => !isRejected(o)).concat(orgs.filter(o => isRejected(o)));
+    const blocked = o => isRejected(o) || isModelRejected(o, model);
+    return orgs.filter(o => !blocked(o)).concat(orgs.filter(blocked));
   }
 
   function forward(org, method, urlPath, headers, body) {
@@ -99,8 +197,10 @@ function createProxy(opts = {}) {
     clientReq.on('end', async () => {
       const body = Buffer.concat(chunks);
       const isModelReq = clientReq.url.startsWith('/v1/messages');
-      const order = pickOrder();
+      const model = isModelReq ? requestModel(body) : '';
+      const order = pickOrder(model);
       let attempt = 0;
+      let modelRefusals = 0;
       for (const org of order) {
         attempt++;
         let up;
@@ -110,21 +210,70 @@ function createProxy(opts = {}) {
           log(`upstream error via ${org}: ${e.message}`);
           continue;
         }
-        const status5h = up.headers['anthropic-ratelimit-unified-5h-status'];
-        const reset5h = Number(up.headers['anthropic-ratelimit-unified-5h-reset']);
-        const limited = up.statusCode === 429 || status5h === 'rejected';
-        if (limited && isModelReq && attempt < order.length) {
-          rejectedUntil.set(org, Number.isFinite(reset5h) ? reset5h * 1000 : Date.now() + 10 * 60 * 1000);
-          log(`${org} is rate-limited (HTTP ${up.statusCode}, 5h=${status5h ?? '?'}) -> retrying with next org`);
-          up.resume(); // discard the response body and try the next org
+        const hdr = name => up.headers[`anthropic-ratelimit-unified-${name}`];
+        const status5h = hdr('5h-status');
+        const status7d = hdr('7d-status');
+        const claim = hdr('representative-claim');
+        // The 5h and 7d windows cover every model of the org, so only those make
+        // the org as a whole unusable. Other refusals are per model: a used-up
+        // per-model weekly allowance (claim=seven_day_overage_included) or a model
+        // that needs usage credits (429 with no window headers). The overall
+        // "unified-status" header is not used: it also reads "rejected" for those.
+        const orgWide = status5h === 'rejected' || status7d === 'rejected';
+        const limited = up.statusCode === 429 || orgWide;
+        const windows = `5h=${status5h ?? '?'}${claim ? `, claim=${claim}` : ''}`;
+        // A 429 body is a small JSON error; buffer it to log the reason and,
+        // if no org is left, to hand it to the client unchanged.
+        let errBody = null;
+        let reason = '';
+        if (isModelReq && up.statusCode === 429) {
+          try {
+            errBody = await readBody(up, ERROR_BODY_MAX_BYTES);
+          } catch (e) {
+            log(`upstream error via ${org} while reading 429 body: ${e.message}`);
+            continue;
+          }
+          reason = describeError(errBody, up.headers['content-encoding']);
+        }
+        const modelRefused = isModelReq && up.statusCode === 429 && !orgWide;
+        if (modelRefused) {
+          // retry-after is honoured when shorter (a transient per-minute limit
+          // must not keep the preferred org out for long); a long one (a weekly
+          // per-model allowance) is capped so the org is re-checked now and then.
+          const ra = retryAfterMs(up.headers['retry-after']);
+          const ms = Number.isFinite(ra) ? Math.min(ra, MODEL_REJECT_MAX_MS) : MODEL_REJECT_MAX_MS;
+          modelRejectedUntil.set(`${org}|${model}`, Date.now() + ms);
+        }
+        const isLast = attempt >= order.length;
+        if (limited && isModelReq && !isLast) {
+          if (orgWide) {
+            // When both windows are rejected the org is back only after the later reset.
+            const resets = [['5h', status5h], ['7d', status7d]]
+              .filter(([, s]) => s === 'rejected')
+              .map(([w]) => Number(hdr(`${w}-reset`)))
+              .filter(Number.isFinite);
+            rejectedUntil.set(org, resets.length ? Math.max(...resets) * 1000 : Date.now() + ORG_REJECT_FALLBACK_MS);
+            log(`${org} is rate-limited (HTTP ${up.statusCode}, ${windows}) -> retrying with next org${reason ? ` (${reason})` : ''}`);
+          } else {
+            modelRefusals++;
+            log(`${org} rejected model ${logModel(model)} (HTTP ${up.statusCode}, ${windows}, ${reason}) -> retrying with next org; ${org} stays in use for other models`);
+          }
+          if (!errBody) up.resume(); // discard the response body and try the next org
           continue;
         }
         if (isModelReq) {
-          const util = up.headers['anthropic-ratelimit-unified-5h-utilization'];
-          log(`${clientReq.method} ${clientReq.url} via ${org} -> ${up.statusCode} (5h ${status5h ?? '?'} ${util ?? '?'})`);
+          const util = hdr('5h-utilization');
+          log(`${clientReq.method} ${clientReq.url} via ${org} -> ${up.statusCode} (5h ${status5h ?? '?'} ${util ?? '?'})${reason ? ` ${reason}` : ''}`);
+          if (modelRefused && modelRefusals === attempt - 1) {
+            log(`all orgs rejected model ${logModel(model)} -> switch the model (e.g. /model) or wait for that model's limit to reset; the org tokens are not the cause`);
+          }
         }
         clientRes.writeHead(up.statusCode, { ...up.headers, 'x-claude-org': org });
-        up.pipe(clientRes); // SSE streaming is piped through untouched
+        if (errBody) {
+          clientRes.end(errBody);
+        } else {
+          up.pipe(clientRes); // SSE streaming is piped through untouched
+        }
         return;
       }
       clientRes.writeHead(503, { 'content-type': 'application/json' });

package/lib/status.js

@@ -1,5 +1,5 @@
 'use strict';
-const { spawn } = require('child_process');
+const { spawnClaude } = require('./claude-spawn');
 const { listOrgs, readToken } = require('./config');
 const { probe } = require('./probe');
 
@@ -10,8 +10,7 @@ const KEYS_RE_DEFAULT = /"(loggedIn|authMethod|orgName|subscriptionType)"/;
 // Run `claude auth status` and return combined stdout+stderr (like 2>&1).
 function authStatus(envExtra = {}) {
   return new Promise(resolve => {
-    const child = spawn('claude', ['auth', 'status'], {
-      shell: process.platform === 'win32',
+    const child = spawnClaude(['auth', 'status'], {
       env: { ...process.env, ...envExtra },
     });
     const chunks = [];

package/lib/usage.js

@@ -2,16 +2,17 @@
 
 // Usage text shown for `claude-org` with no args (exit 2) and for
 // help/--help/-h (exit 0). Kept compatible with the original bash version.
-const USAGE = `claude-org: launch Claude Code with a specific org's long-lived token
+const USAGE = `claude-org (alias: ccorg): launch Claude Code with a specific org's long-lived token
   (switch between the "default org" login and "token orgs").
 
-Background: when one email has multiple Claude orgs (e.g. a personal plan org and
-a company Team org) and you hit the usage limit, you want to continue on the other
+Background: when one email has multiple Claude orgs (e.g. a personal org and
+your company's org) and you hit the usage limit, you want to continue on the other
 org with --resume. Claude Code has no org-switch command, but
 CLAUDE_CODE_OAUTH_TOKEN (env) takes precedence over the saved OAuth login
 (https://code.claude.com/docs/en/authentication "Authentication precedence").
 Get a token per org with \`claude setup-token\` (valid 1 year) and store it as
-~/.claude/org-tokens/<name>.token. The plain login (no env) org is called "default";
+~/.claude/org-tokens/<name>.token. <name> is any label you choose (e.g. work,
+personal). The plain login (no env) org is called "default";
 no token file is needed for it.
 
 Usage (<prefer> resolves: CLAUDE_ORG_PREFER -> first of CLAUDE_ORG_ORDER -> first
@@ -22,7 +23,7 @@ token org alphabetically):
                                     connector MCPs are unavailable)
   claude-org auto [claude args...]    launch on <prefer> if usable, else default
                                     (decided once at launch)
-  claude-org <name> [claude args...]  e.g. claude-org team --resume
+  claude-org <name> [claude args...]  e.g. claude-org work --resume
   claude-org probe [<name>]           print the org's 5h window state on one line
                                     (exit 0 when allowed)
   claude-org watch                    wait until <prefer> recovers, then notify

package/lib/watch.js

@@ -1,5 +1,6 @@
 'use strict';
 const { spawn } = require('child_process');
+const { q } = require('./claude-spawn');
 const { resolvePrefer } = require('./config');
 const { probe } = require('./probe');
 const { hhmmss } = require('./time');
@@ -16,7 +17,6 @@ function notify(title, message) {
   }
   // Quote args ourselves: spawn(shell:true) does not quote on Windows and the
   // title/message contain spaces.
-  const q = s => `"${String(s).replace(/(["\\$`])/g, '\\$1')}"`;
   return new Promise(resolve => {
     const child = spawn(`${cmd} ${q(title)} ${q(message)}`, { shell: true, stdio: 'ignore' });
     child.on('error', () => {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "claude-org",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "Switch Claude Code between multiple Anthropic organizations, with automatic failover on the 5-hour rate limit",
   "license": "MIT",
   "type": "commonjs",
   "bin": {
-    "claude-org": "bin/claude-org.js"
+    "claude-org": "bin/claude-org.js",
+    "ccorg": "bin/claude-org.js"
   },
   "engines": {
     "node": ">=18"
@@ -18,7 +19,8 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "node --test"
+    "test": "node --test",
+    "release": "node scripts/release.js"
   },
   "keywords": [
     "claude-code",