claude-org 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 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.
+
+- `claude-org` CLI: `proxy` / `auto` / `<name>` / `probe` / `watch` / `status` / `list`
+- Dependency-free Node.js 18+ implementation (fetch / child_process); works on Windows, macOS, Linux
+- `proxy`: session-scoped localhost proxy that rewrites `Authorization` per request and fails over to the next org on HTTP 429 or `5h-status=rejected`; SSE passthrough
+- `proxy`: launches `claude` with `CLAUDE_CODE_PROMPT_CACHE_TTL=1h` and `ENABLE_TOOL_SEARCH=true` (user-set values win) to restore subscription-equivalent behavior under custom `ANTHROPIC_BASE_URL`; forwards `anthropic-beta` unchanged
+- `watch`: recovery polling with externalized notification via `CLAUDE_ORG_NOTIFY_CMD`
+- Preferred-org resolution: `CLAUDE_ORG_PREFER` -> `CLAUDE_ORG_ORDER` head -> first token file alphabetically
+- Compatibility exception vs the original bash version: `help`/`--help`/`-h` exit 0 (was 2)

package/LICENSE

@@ -0,0 +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.

package/README.md

@@ -1,3 +1,135 @@
-# Temporary Holding Version
+# claude-org
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+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 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.
+
+## Install
+
+```sh
+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
+
+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
+   ```
+
+   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 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/work.token
+   ```
+
+   ```powershell
+   # PowerShell
+   New-Item -ItemType Directory -Force "$env:USERPROFILE\.claude\org-tokens" | Out-Null
+   Set-Content -NoNewline "$env:USERPROFILE\.claude\org-tokens\work.token" "<token>"
+   ```
+
+   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
+
+| Command | What it does |
+|---|---|
+| `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 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. |
+| `claude-org list` | List saved org names. |
+
+`auto` and `<name>` only read env at launch — they cannot switch a running session. Settings, plugins, and session history live under `~/.claude/` and are shared across orgs, so `claude-org auto --resume` continues a session started under the other org.
+
+The **preferred org** (used by `auto`, `watch`, and as `proxy`'s first candidate) resolves in this order: `CLAUDE_ORG_PREFER` -> first entry of `CLAUDE_ORG_ORDER` -> first `.token` file alphabetically.
+
+## proxy mode
+
+```
+claude-org proxy --resume
+```
+
+1. A session-scoped proxy starts on `127.0.0.1:<random port>` (one per session; no port collisions).
+2. `claude` launches with `ANTHROPIC_BASE_URL` pointing at the proxy and a **dummy** bearer token.
+3. The proxy replaces the `Authorization` header with a real org token and forwards to `api.anthropic.com`. On a 429 or `anthropic-ratelimit-unified-5h-status: rejected` it marks that org limited until `5h-reset` and **resends the same request** with the next org's token.
+4. Claude Code only ever sees the successful response — the org switched mid-session. SSE streaming is piped through untouched.
+
+One log line per request (`via <org> -> <status>`) goes to a temp file printed at launch (`-> proxy 127.0.0.1:<port> (order: ..., log: ...)`).
+
+**Limitations of proxy mode**
+
+- claude.ai connector MCPs (Gmail / Drive / Calendar / Notion / Slack …) and Remote Control are **unavailable**: `ANTHROPIC_AUTH_TOKEN` makes Claude Code treat the session as external-token auth, so `mcp__claude_ai_*` tools do not appear. Local/plugin MCPs work. Open connectors in a plain `claude --resume` session — history is shared.
+- Each proxy serves one session and dies when `claude` exits.
+
+### Prompt cache & tool search
+
+A custom `ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN` makes Claude Code treat the session as API-key auth, which changes two defaults:
+
+- **Prompt cache TTL drops to 5 minutes** (subscription-direct sessions get 1 hour). The 1-hour TTL is requested via the `anthropic-beta` header, which the proxy forwards unchanged.
+- **MCP tool search** (deferred tool-definition loading) is **disabled**.
+
+`claude-org proxy` restores the subscription-equivalent behavior by launching `claude` with `CLAUDE_CODE_PROMPT_CACHE_TTL=1h` and `ENABLE_TOOL_SEARCH=true`. If you have set either variable yourself, your value wins.
+
+| Entry point | Mid-session switch | Connector MCPs | Best for |
+|---|---|---|---|
+| `claude` | no (default org) | yes | connector work |
+| `claude-org auto --resume` | at launch only | no on preferred org / yes on default | short tasks |
+| `claude-org proxy --resume` | **automatic** | no | long-running work, agents |
+
+## Environment variables
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `CLAUDE_ORG_PREFER` | (unset) | Preferred org for `auto` / `watch` / `proxy` |
+| `CLAUDE_ORG_ORDER` | (unset) | Comma-separated org priority for `proxy`; unlisted orgs follow alphabetically |
+| `CLAUDE_ORG_TOKEN_DIR` | `~/.claude/org-tokens` | Where `<name>.token` files live |
+| `CLAUDE_ORG_NOTIFY_CMD` | (unset) | `watch` notification command, run as `<cmd> "<title>" "<message>"` via the OS shell |
+| `CLAUDE_ORG_WATCH_MAX_SLEEP` | `18000` | Max seconds between `watch` re-checks (values < 60 also lower the 60s minimum — for tests) |
+| `CLAUDE_ORG_UPSTREAM` | `https://api.anthropic.com` | API base URL for `probe` and `proxy` (stub upstream in tests) |
+| `CLAUDE_ORG_PROXY` | `1` when launched via `proxy` | Marker env passed to the claude process so user hooks can detect connector-less sessions |
+| `CLAUDE_ORG_FORCE_PROBE` | (unset) | Test seam: `allowed` / `rejected[:<epoch>]` / `rejected_until:<epoch>` fakes `probe` results without API calls |
+| `CLAUDE_ORG_REJECT_FILE` | (unset) | Test seam: orgs listed comma-separated in this file are treated as rate-limited by `proxy` |
+
+## Notes
+
+- **Token safety**: tokens are read from files only and never printed to logs, errors, or test snapshots. The proxy binds to `127.0.0.1` only.
+- **probe cost**: each `probe` sends one `max_tokens=1` request (~11 tokens billed to that org), once per `auto` launch.
+- **Token expiry**: tokens last ~1 year. If `probe` returns `status=unknown` or `status` shows `(auth status failed)`, rerun `claude setup-token` and overwrite the file.
+
+## A note on terms
+
+claude-org only switches between Anthropic organizations **you personally belong to**, using long-lived tokens you generated yourself via `claude setup-token`. All traffic stays on your machine (the proxy binds to 127.0.0.1). Per Anthropic's authentication docs, OAuth tokens are intended for ordinary use of Claude Code — do not use this tool to route other people's requests through your subscription credentials. Each org's usage is billed/limited to that org as usual. Check [Anthropic's Usage Policy](https://www.anthropic.com/legal/aup) and your plan's terms yourself before use. Commands that mention token env names may also be blocked by safety hooks in hardened Claude Code setups.
+
+## Development
+
+```sh
+npm test            # node:test suite, no real API calls
+npm pack --dry-run  # inspect the published file set
+```
+
+## License
+
+MIT

package/bin/claude-org.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+'use strict';
+
+const { printUsage } = require('../lib/usage');
+const { listOrgs, resolvePrefer } = require('../lib/config');
+const { probe } = require('../lib/probe');
+const { pick } = require('../lib/pick');
+const { launch } = require('../lib/launch');
+const { statusAll } = require('../lib/status');
+const { watch } = require('../lib/watch');
+const { proxyLaunch } = require('../lib/proxy');
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  switch (cmd) {
+    case undefined:
+      return printUsage(2);
+    case '-h':
+    case '--help':
+    case 'help':
+      return printUsage(0);
+    case 'list':
+      for (const o of listOrgs()) console.log(o);
+      return 0;
+    case 'status':
+      return statusAll();
+    case 'probe': {
+      const r = await probe(rest[0] || resolvePrefer());
+      if (r.line) console.log(r.line);
+      return r.allowed ? 0 : 1;
+    }
+    case 'pick':
+      console.log(await pick());
+      return 0;
+    case 'auto':
+      return launch(await pick(), rest);
+    case 'watch':
+      return watch();
+    case 'proxy':
+      return proxyLaunch(rest);
+    default:
+      // <name> launches claude with that org's token.
+      return launch(cmd, rest);
+  }
+}
+
+main()
+  .then(code => process.exit(code))
+  .catch(e => {
+    console.error(`claude-org: ${e.message}`);
+    process.exit(1);
+  });

package/lib/config.js

@@ -0,0 +1,55 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function tokenDir() {
+  return process.env.CLAUDE_ORG_TOKEN_DIR || path.join(os.homedir(), '.claude', 'org-tokens');
+}
+
+// Saved org names: *.token files, extension stripped, sorted.
+function listOrgs(dir = tokenDir()) {
+  let files;
+  try {
+    files = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return files.filter(f => f.endsWith('.token')).map(f => f.slice(0, -6)).sort();
+}
+
+// Read a token file, stripping CR/LF. Returns null (after printing guidance)
+// when the file is missing or empty.
+function readToken(name, dir = tokenDir()) {
+  const f = path.join(dir, `${name}.token`);
+  let raw = '';
+  try {
+    raw = fs.readFileSync(f, 'utf8');
+  } catch {
+    /* fall through to the error below */
+  }
+  if (!raw.trim()) {
+    console.error(`claude-org: token file not found: ${f}`);
+    console.error(`  取得: claude setup-token でブラウザから org '${name}' を選び、出力トークンを ${f} に保存（改行なし）`);
+    return null;
+  }
+  return raw.replace(/[\r\n]/g, '');
+}
+
+// Preferred org resolution order:
+//   1. CLAUDE_ORG_PREFER
+//   2. first entry of CLAUDE_ORG_ORDER
+//   3. first .token file in the token dir (alphabetical, same rule as the proxy)
+//   4. no tokens at all -> print setup guidance and exit 1
+function resolvePrefer() {
+  if (process.env.CLAUDE_ORG_PREFER) return process.env.CLAUDE_ORG_PREFER;
+  const order = (process.env.CLAUDE_ORG_ORDER || '').split(',').map(s => s.trim()).filter(Boolean);
+  if (order.length) return order[0];
+  const orgs = listOrgs();
+  if (orgs.length) return orgs[0];
+  console.error(`claude-org: no org tokens found in ${tokenDir()}`);
+  console.error(`  取得: claude setup-token で org を選び、出力トークンを ${tokenDir()}/<name>.token に保存（改行なし）`);
+  process.exit(1);
+}
+
+module.exports = { tokenDir, listOrgs, readToken, resolvePrefer };

package/lib/launch.js

@@ -0,0 +1,34 @@
+'use strict';
+const { spawn } = require('child_process');
+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, {
+      stdio: 'inherit',
+      shell: process.platform === 'win32', // resolves claude.cmd on Windows
+      env: { ...process.env, ...envExtra },
+    });
+    child.on('error', e => {
+      console.error(`claude-org: failed to launch claude: ${e.message}`);
+      resolve(1);
+    });
+    child.on('exit', (code, signal) => {
+      if (code !== null) return resolve(code);
+      resolve(signal ? 128 + ({ SIGINT: 2, SIGTERM: 15 }[signal] || 1) : 1);
+    });
+  });
+}
+
+// launch(name, args): 'default' launches a plain `claude`; a token org launches
+// with CLAUDE_CODE_OAUTH_TOKEN set. Returns the process exit code.
+async function launch(name, args) {
+  if (name === 'default') return runClaude(args);
+  const tok = readToken(name);
+  if (tok === null) return 1;
+  return runClaude(args, { CLAUDE_CODE_OAUTH_TOKEN: tok });
+}
+
+module.exports = { runClaude, launch };

package/lib/pick.js

@@ -0,0 +1,21 @@
+'use strict';
+const { resolvePrefer } = require('./config');
+const { probe } = require('./probe');
+
+// pick(): which org `auto` should launch on. Returns 'default' when the
+// preferred org is over its 5h limit (or its token is missing). The decision
+// reason goes to stderr as a single `-> ...` line.
+async function pick() {
+  const prefer = resolvePrefer();
+  const r = await probe(prefer);
+  if (r.allowed) {
+    let util = r.util;
+    if (util !== '?') util = `${Math.trunc(Number(util) * 100)}%`;
+    console.error(`-> ${prefer} (5h ${util} used)`);
+    return prefer;
+  }
+  console.error(`-> default (${prefer} is ${r.status}, resets ${r.resetLocal})`);
+  return 'default';
+}
+
+module.exports = { pick };

package/lib/probe.js

@@ -0,0 +1,61 @@
+'use strict';
+const { readToken } = require('./config');
+const { epochToHHMM } = require('./time');
+
+// probe(name): send a 1-token inference request and read the unified 5h
+// rate-limit headers. Returns { line, status, util, reset, resetLocal, allowed }.
+// `line` is the canonical one-line output:
+//   status=<allowed|rejected|unknown> 5h_util=<0.xx|?> 5h_reset=<epoch|?> 5h_reset_local=<HH:MM|?>
+//
+// Test seam: CLAUDE_ORG_FORCE_PROBE = allowed | rejected[:<epoch>] |
+// rejected_until:<epoch> (rejected_until flips to allowed once <epoch> passes).
+// When forced, the token file is not required and no request is sent.
+// CLAUDE_ORG_UPSTREAM overrides the API base URL (stub upstream in tests).
+async function probe(name) {
+  const forced = process.env.CLAUDE_ORG_FORCE_PROBE;
+  let status, util, reset;
+  if (forced) {
+    const idx = forced.indexOf(':');
+    status = idx === -1 ? forced : forced.slice(0, idx);
+    reset = idx === -1 ? '?' : forced.slice(idx + 1);
+    if (status === 'rejected_until') {
+      status = Math.floor(Date.now() / 1000) >= Number(reset) ? 'allowed' : 'rejected';
+    }
+    util = '?';
+  } else {
+    const tok = readToken(name);
+    if (tok === null) return { line: null, status: 'unknown', util: '?', reset: '?', resetLocal: '?', allowed: false };
+    const base = (process.env.CLAUDE_ORG_UPSTREAM || 'https://api.anthropic.com').replace(/\/+$/, '');
+    let headers = null;
+    try {
+      const res = await fetch(`${base}/v1/messages`, {
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${tok}`,
+          'anthropic-beta': 'oauth-2025-04-20',
+          'anthropic-version': '2023-06-01',
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: 'claude-haiku-4-5-20251001',
+          max_tokens: 1,
+          messages: [{ role: 'user', content: 'hi' }],
+        }),
+        signal: AbortSignal.timeout(20000),
+      });
+      headers = res.headers;
+      res.body && res.body.cancel().catch(() => {});
+    } catch {
+      headers = null;
+    }
+    status = (headers && (headers.get('anthropic-ratelimit-unified-5h-status')
+      || headers.get('anthropic-ratelimit-unified-status'))) || 'unknown';
+    util = (headers && headers.get('anthropic-ratelimit-unified-5h-utilization')) || '?';
+    reset = (headers && headers.get('anthropic-ratelimit-unified-5h-reset')) || '?';
+  }
+  const resetLocal = reset !== '?' ? epochToHHMM(reset) : '?';
+  const line = `status=${status} 5h_util=${util} 5h_reset=${reset} 5h_reset_local=${resetLocal}`;
+  return { line, status, util, reset, resetLocal, allowed: status === 'allowed' };
+}
+
+module.exports = { probe };

package/lib/proxy.js

@@ -0,0 +1,199 @@
+'use strict';
+// Local proxy between Claude Code and the Anthropic API. It rewrites the
+// Authorization header to the token of "the org that is currently usable" and,
+// when it sees the 5h limit (HTTP 429 or response header
+// anthropic-ratelimit-unified-5h-status: rejected), resends the same request
+// with the next org's token. A running Claude Code session never sees the 429,
+// so the org switches without a restart.
+//
+// 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.
+//
+// Env (standalone mode):
+//   PORT                   listen port (default 0 = OS picks; reported on the
+//                          "listening on" stderr line)
+//   CLAUDE_ORG_TOKEN_DIR   where <name>.token files live (~/.claude/org-tokens)
+//   CLAUDE_ORG_ORDER       org priority, comma-separated (default: alphabetical)
+//   CLAUDE_ORG_UPSTREAM    forward target (default https://api.anthropic.com)
+//   CLAUDE_ORG_REJECT_FILE test seam: orgs listed comma-separated in this file
+//                          are treated as rate-limited
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function createProxy(opts = {}) {
+  const TOKEN_DIR = opts.tokenDir || process.env.CLAUDE_ORG_TOKEN_DIR
+    || path.join(os.homedir(), '.claude', 'org-tokens');
+  const ORDER = opts.order
+    || (process.env.CLAUDE_ORG_ORDER || '').split(',').map(s => s.trim()).filter(Boolean);
+  const UPSTREAM = new URL(opts.upstream || process.env.CLAUDE_ORG_UPSTREAM || 'https://api.anthropic.com');
+  const REJECT_FILE = 'rejectFile' in opts ? opts.rejectFile : (process.env.CLAUDE_ORG_REJECT_FILE || '');
+  const out = opts.log || process.stderr;
+  const transport = UPSTREAM.protocol === 'http:' ? http : https;
+
+  function log(...a) {
+    out.write(`[claude-org-proxy ${new Date().toISOString().slice(11, 19)}] ${a.join(' ')}\n`);
+  }
+
+  function listOrgs() {
+    const files = fs.readdirSync(TOKEN_DIR).filter(f => f.endsWith('.token')).map(f => f.slice(0, -6)).sort();
+    if (ORDER.length === 0) return files;
+    const known = new Set(files);
+    return ORDER.filter(o => known.has(o)).concat(files.filter(f => !ORDER.includes(f)));
+  }
+  function readToken(name) {
+    return fs.readFileSync(path.join(TOKEN_DIR, `${name}.token`), 'utf8').replace(/[\r\n]/g, '');
+  }
+
+  // Per-org "rate-limited" memory: name -> recovery epoch (ms). Expired entries
+  // automatically re-enter the candidate pool.
+  const rejectedUntil = new Map();
+  function fileRejected(name) {
+    if (!REJECT_FILE) return false;
+    try {
+      return fs.readFileSync(REJECT_FILE, 'utf8').split(',').map(s => s.trim()).includes(name);
+    } catch {
+      return false;
+    }
+  }
+  function isRejected(name) {
+    if (fileRejected(name)) return true;
+    const until = rejectedUntil.get(name);
+    if (until === undefined) return false;
+    if (Date.now() >= until) { rejectedUntil.delete(name); return false; }
+    return true;
+  }
+  // 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() {
+    const orgs = listOrgs();
+    return orgs.filter(o => !isRejected(o)).concat(orgs.filter(o => isRejected(o)));
+  }
+
+  function forward(org, method, urlPath, headers, body) {
+    return new Promise((resolve, reject) => {
+      const h = { ...headers };
+      for (const k of Object.keys(h)) {
+        const lk = k.toLowerCase();
+        if (lk === 'x-api-key' || lk === 'host' || lk === 'content-length' || lk === 'authorization') delete h[k];
+      }
+      h.authorization = `Bearer ${readToken(org)}`;
+      h.host = UPSTREAM.host;
+      if (body.length) h['content-length'] = String(body.length);
+      const req = transport.request(
+        { hostname: UPSTREAM.hostname, port: UPSTREAM.port || (transport === https ? 443 : 80), path: urlPath, method, headers: h },
+        res => resolve(res),
+      );
+      req.on('error', reject);
+      if (body.length) req.write(body);
+      req.end();
+    });
+  }
+
+  const server = http.createServer((clientReq, clientRes) => {
+    const chunks = [];
+    clientReq.on('data', c => chunks.push(c));
+    clientReq.on('end', async () => {
+      const body = Buffer.concat(chunks);
+      const isModelReq = clientReq.url.startsWith('/v1/messages');
+      const order = pickOrder();
+      let attempt = 0;
+      for (const org of order) {
+        attempt++;
+        let up;
+        try {
+          up = await forward(org, clientReq.method, clientReq.url, clientReq.headers, body);
+        } catch (e) {
+          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
+          continue;
+        }
+        if (isModelReq) {
+          const util = up.headers['anthropic-ratelimit-unified-5h-utilization'];
+          log(`${clientReq.method} ${clientReq.url} via ${org} -> ${up.statusCode} (5h ${status5h ?? '?'} ${util ?? '?'})`);
+        }
+        clientRes.writeHead(up.statusCode, { ...up.headers, 'x-claude-org': org });
+        up.pipe(clientRes); // SSE streaming is piped through untouched
+        return;
+      }
+      clientRes.writeHead(503, { 'content-type': 'application/json' });
+      clientRes.end(JSON.stringify({ type: 'error', error: { type: 'claude_org_proxy', message: 'all orgs rate-limited or unreachable' } }));
+    });
+  });
+
+  return { server, listOrgs, log, upstream: UPSTREAM };
+}
+
+// `claude-org proxy [claude args...]`: start an in-process proxy on a random
+// port, point ANTHROPIC_BASE_URL at it, launch claude, and shut the proxy down
+// when claude exits. One proxy per session, so parallel sessions never collide.
+async function proxyLaunch(args) {
+  const { listOrgs, tokenDir, resolvePrefer } = require('./config');
+  const { runClaude } = require('./launch');
+
+  const orgs = listOrgs();
+  if (orgs.length < 2) {
+    console.error(`claude-org: proxy には org トークンが 2 つ以上必要です（${tokenDir()} に ${orgs.join(' ')}）`);
+    console.error(`  取得: claude setup-token でもう片方の org を選び、${tokenDir()}/<name>.token に保存`);
+    return 1;
+  }
+
+  const order = process.env.CLAUDE_ORG_ORDER || resolvePrefer();
+  const logf = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'claude-org-proxy-')), 'proxy.log');
+  const logStream = fs.createWriteStream(logf);
+  const { server, log, upstream } = createProxy({ order: order.split(','), log: logStream });
+
+  try {
+    await new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(0, '127.0.0.1', () => {
+        log(`listening on http://127.0.0.1:${server.address().port} orgs=${listOrgs().join(',')} upstream=${upstream.host}`);
+        resolve();
+      });
+    });
+  } catch (e) {
+    console.error(`claude-org: proxy が起動しませんでした: ${e.message}`);
+    return 1;
+  }
+  const port = server.address().port;
+  console.error(`-> proxy 127.0.0.1:${port} (order: ${order}, log: ${logf})`);
+
+  // A custom ANTHROPIC_BASE_URL + AUTH_TOKEN makes Claude Code treat the session
+  // as API-key auth: prompt cache TTL drops to 5min and MCP tool search is
+  // disabled. Restore subscription-equivalent defaults; user-set values win.
+  const envExtra = {
+    ANTHROPIC_BASE_URL: `http://127.0.0.1:${port}`,
+    ANTHROPIC_AUTH_TOKEN: 'claude-org-proxy', // dummy; the proxy replaces it
+    CLAUDE_ORG_PROXY: '1',                    // marker: "connector MCPs unavailable" session
+  };
+  if (!process.env.CLAUDE_CODE_PROMPT_CACHE_TTL) envExtra.CLAUDE_CODE_PROMPT_CACHE_TTL = '1h';
+  if (!process.env.ENABLE_TOOL_SEARCH) envExtra.ENABLE_TOOL_SEARCH = 'true';
+
+  const rc = await runClaude(args, envExtra);
+  server.close();
+  logStream.end();
+  return rc;
+}
+
+// Standalone mode: `node lib/proxy.js` (env-driven, same as the bash version's
+// `node claude-org-proxy.js`).
+if (require.main === module) {
+  const PORT = Number(process.env.PORT || 0);
+  const { server, listOrgs, log, upstream } = createProxy();
+  server.listen(PORT, '127.0.0.1', () => {
+    log(`listening on http://127.0.0.1:${server.address().port} orgs=${listOrgs().join(',')} upstream=${upstream.host}`);
+  });
+}
+
+module.exports = { createProxy, proxyLaunch };

package/lib/status.js

@@ -0,0 +1,42 @@
+'use strict';
+const { spawn } = require('child_process');
+const { listOrgs, readToken } = require('./config');
+const { probe } = require('./probe');
+
+const KEYS = '"(loggedIn|authMethod|orgName|subscriptionType|email)"';
+const KEYS_RE = /"(loggedIn|authMethod|orgName|subscriptionType|email)"/;
+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',
+      env: { ...process.env, ...envExtra },
+    });
+    const chunks = [];
+    child.stdout.on('data', c => chunks.push(c));
+    child.stderr.on('data', c => chunks.push(c));
+    child.on('error', () => resolve(''));
+    child.on('close', () => resolve(Buffer.concat(chunks).toString('utf8')));
+  });
+}
+
+async function statusAll() {
+  for (const name of listOrgs()) {
+    const tok = readToken(name);
+    if (tok === null) continue;
+    console.log(`== ${name} ==`);
+    const out = await authStatus({ CLAUDE_CODE_OAUTH_TOKEN: tok });
+    const lines = out.split('\n').filter(l => KEYS_RE.test(l));
+    console.log(lines.length ? lines.join('\n') : '  (auth status failed)');
+    const r = await probe(name);
+    if (r.line) console.log(`  ${r.line}`);
+  }
+  console.log('== default (no env) ==');
+  const out = await authStatus();
+  console.log(out.split('\n').filter(l => KEYS_RE_DEFAULT.test(l)).join('\n'));
+  return 0;
+}
+
+module.exports = { statusAll, KEYS };

package/lib/time.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// epoch seconds -> local HH:MM ('?' on garbage). Replaces the GNU/BSD `date`
+// dependency of the bash version.
+function epochToHHMM(epochSec) {
+  const d = new Date(Number(epochSec) * 1000);
+  if (Number.isNaN(d.getTime())) return '?';
+  const p = n => String(n).padStart(2, '0');
+  return `${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+function hhmmss(d = new Date()) {
+  const p = n => String(n).padStart(2, '0');
+  return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+
+module.exports = { epochToHHMM, hhmmss };

package/lib/usage.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// 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 (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 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. <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
+token org alphabetically):
+  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; claude.ai
+                                    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 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
+                                    (terminal + optional CLAUDE_ORG_NOTIFY_CMD)
+  claude-org status                   show \`claude auth status\` for each org token
+  claude-org list                     list saved org names
+
+auto / <name> only read env at launch, so they cannot switch mid-session. To keep
+switching while running, use proxy (Claude Code never sees the 429; the proxy
+resends on another org).
+`;
+
+function printUsage(exitCode) {
+  process.stdout.write(USAGE);
+  return exitCode;
+}
+
+module.exports = { USAGE, printUsage };

package/lib/watch.js

@@ -0,0 +1,64 @@
+'use strict';
+const { spawn } = require('child_process');
+const { resolvePrefer } = require('./config');
+const { probe } = require('./probe');
+const { hhmmss } = require('./time');
+
+const sleep = s => new Promise(r => setTimeout(r, s * 1000));
+
+// Externalized notification: CLAUDE_ORG_NOTIFY_CMD is run as
+// `<cmd> <title> <message>` via the OS shell. Terminal output always happens.
+function notify(title, message) {
+  const cmd = process.env.CLAUDE_ORG_NOTIFY_CMD;
+  if (!cmd) {
+    console.log('  (CLAUDE_ORG_NOTIFY_CMD 未設定のため端末通知のみ)');
+    return Promise.resolve();
+  }
+  // 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', () => {
+      console.log('  (通知コマンドの実行に失敗。端末通知のみ)');
+      resolve();
+    });
+    child.on('close', code => {
+      if (code) console.log('  (通知コマンドが失敗。端末通知のみ)');
+      resolve();
+    });
+  });
+}
+
+// watch: poll the preferred org until its 5h window recovers, notify once, exit.
+// Re-check interval: (5h_reset - now + 30s), clamped to [min, max]. max is
+// CLAUDE_ORG_WATCH_MAX_SLEEP (default 18000s); min is 60s unless max < 60,
+// in which case min = max (so tests can shrink the loop).
+async function watch() {
+  const prefer = resolvePrefer();
+  const maxSleep = Number(process.env.CLAUDE_ORG_WATCH_MAX_SLEEP || 18000);
+  let minSleep = 60;
+  if (maxSleep < minSleep) minSleep = maxSleep;
+
+  for (;;) {
+    const r = await probe(prefer);
+    if (r.allowed) {
+      console.log(`${hhmmss()} ${prefer} 復活: ${r.line}`);
+      console.log('  → claude-org auto --resume で戻れます');
+      await notify(`Claude ${prefer} 復活`, `claude-org auto --resume で ${prefer} に戻れます`);
+      return 0;
+    }
+    const nowSec = Math.floor(Date.now() / 1000);
+    let wait;
+    if (r.reset !== '?' && Number(r.reset) > nowSec) {
+      wait = Number(r.reset) - nowSec + 30;
+    } else {
+      wait = 600;
+    }
+    wait = Math.min(Math.max(wait, minSleep), maxSleep);
+    console.log(`${hhmmss()} ${prefer} 上限中 (${r.line}) → ${wait}s 後に再確認 (reset ${r.resetLocal})`);
+    await sleep(wait);
+  }
+}
+
+module.exports = { watch };

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "claude-org",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "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",
+    "ccorg": "bin/claude-org.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "claude-code",
+    "anthropic",
+    "cli",
+    "rate-limit",
+    "failover"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/miyashita337/claude-org.git"
+  },
+  "homepage": "https://github.com/miyashita337/claude-org",
+  "bugs": "https://github.com/miyashita337/claude-org/issues"
+}