@carjms/codexswitch 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JI MyungSik
+
+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

@@ -0,0 +1,274 @@
+# codexswitch
+
+**OpenAI Codex CLI 계정을 여러 개 등록해두고, 클릭 한 번(명령 한 줄)으로 전환하거나, 사용량 한도에 걸리면 자동으로 다음 계정으로 넘어가게 해주는 도구입니다.**
+
+[KarpelesLab/teamclaude](https://github.com/KarpelesLab/teamclaude)(Claude용 멀티 계정 도구)에서 영감을 받아 Codex CLI에 맞게 만들었습니다. macOS / Windows / Linux를 지원하며, Node.js만 있으면 되고 외부 의존성은 없습니다.
+
+## 이런 분께 필요합니다
+
+- ChatGPT 계정이 2개 이상 있고(개인용/회사용, Plus/Pro 등) Codex를 계정 바꿔가며 쓰고 싶은 분
+- 한 계정의 사용량 한도(usage limit)가 차면 **자동으로 다른 계정으로 이어서** 작업하고 싶은 분
+- 매번 `codex logout` → `codex login`을 반복하는 게 지겨운 분
+
+Codex CLI는 로그인 정보를 한 파일(`auth.json`)에만 저장해서 원래 계정 1개만 쓸 수 있습니다. codexswitch이 이 한계를 풀어줍니다.
+
+---
+
+## 1. 준비물
+
+두 가지가 미리 설치되어 있어야 합니다.
+
+### ① Node.js (v18 이상)
+
+터미널에서 `node --version`을 입력했을 때 `v18` 이상이 나오면 이 단계는 건너뛰세요.
+
+- **macOS**: [nodejs.org](https://nodejs.org/)에서 LTS 버전 설치 파일(.pkg)을 받아 실행하거나, Homebrew가 있다면 터미널에서:
+  ```bash
+  brew install node
+  ```
+- **Windows**: [nodejs.org](https://nodejs.org/)에서 LTS 버전 설치 파일(.msi)을 받아 실행하세요. 설치 중 옵션은 전부 기본값 그대로 "다음"만 눌러도 됩니다.
+
+### ② Codex CLI
+
+- **macOS** — 터미널(응용 프로그램 → 유틸리티 → 터미널)에서:
+  ```bash
+  npm install -g @openai/codex
+  ```
+- **Windows** — PowerShell(시작 메뉴에서 "PowerShell" 검색 → 실행)에서:
+  ```powershell
+  npm install -g @openai/codex
+  ```
+  > 참고: Codex CLI는 Windows 네이티브 지원이 실험적(experimental) 단계라, OpenAI는 WSL(Windows Subsystem for Linux) 사용을 권장합니다. WSL을 쓰신다면 WSL 터미널 안에서 macOS/Linux 방법을 그대로 따라 하시면 됩니다.
+
+설치 확인:
+
+```bash
+codex --version
+```
+
+---
+
+## 2. codexswitch 설치
+
+macOS와 Windows 모두 같은 명령입니다 (macOS는 터미널, Windows는 PowerShell):
+
+```bash
+npm install -g @carjms/codexswitch
+```
+
+설치 확인:
+
+```bash
+codexswitch help
+```
+
+도움말이 나오면 성공입니다. `codexswitch`과 짧은 별칭 `cxs` 두 명령 모두 똑같이 동작합니다 (아래 예시는 짧은 `cxs`를 사용합니다).
+
+---
+
+## 3. 처음 시작하기 (5분 가이드)
+
+계정 2개를 등록하고 전환해보는 전체 과정입니다.
+
+### 3-1. 이미 로그인된 계정 등록하기
+
+전에 `codex login`을 해본 적이 있다면, 그 계정을 그대로 가져옵니다:
+
+```bash
+cxs import
+```
+
+```
+added account "me@gmail.com" (me@gmail.com, plus)
+set "me@gmail.com" as the active account
+```
+
+이름을 직접 붙이고 싶다면 `cxs import 개인용` 처럼 뒤에 이름을 쓰면 됩니다.
+
+> 아직 한 번도 로그인한 적이 없다면 이 단계는 건너뛰고 3-2로 가세요.
+
+### 3-2. 두 번째 계정 로그인하기
+
+```bash
+cxs login 회사용
+```
+
+브라우저가 열리면 **추가할 ChatGPT 계정으로** 로그인하세요. (이미 브라우저에 다른 계정이 로그인돼 있다면 로그인 화면에서 계정을 전환하세요.)
+
+> 이 과정은 격리된 임시 공간에서 진행되므로 **기존 계정 로그인은 전혀 건드리지 않습니다.**
+
+### 3-3. 등록된 계정 확인
+
+```bash
+cxs list
+```
+
+```
+   name          email             plan  prio  status  token refreshed
+-  ------------  ----------------  ----  ----  ------  ----------------
+*  me@gmail.com  me@gmail.com      plus  0     ok      2026-07-08 09:12
+   회사용         work@company.com  pro   0     ok      2026-07-08 09:15
+```
+
+`*` 표시가 현재 활성 계정입니다.
+
+### 3-4. 계정 전환
+
+```bash
+cxs use 회사용
+```
+
+이제부터 평소처럼 `codex`를 실행하면 회사용 계정으로 동작합니다. 다시 바꾸려면 `cxs use me@gmail.com`, 또는 `cxs next`(다음 계정으로 순환).
+
+### 3-5. 한도 자동 전환으로 실행하기 (핵심 기능)
+
+```bash
+cxs exec "이 프로젝트의 테스트 코드를 작성해줘"
+```
+
+`codex exec`를 실행하다가 **사용량 한도에 걸리면**:
+
+1. 그 계정을 일정 시간 "한도 걸림"으로 표시하고 (에러 메시지의 "try again in 2 hours" 같은 시간을 자동 인식)
+2. 다음 사용 가능한 계정으로 **같은 명령을 자동 재시도**합니다
+3. 모든 계정이 소진되면 그때 멈춥니다
+
+```
+[codexswitch] exec as "me@gmail.com"
+... (작업 중 한도 도달) ...
+[codexswitch] "me@gmail.com" hit a usage/rate limit (paused until 2026-07-08 14:30) — rotating
+[codexswitch] exec as "회사용" (attempt 2)
+... (이어서 작업) ...
+```
+
+### 3-6. 계정 전환 없이 특정 계정으로 실행
+
+전역 활성 계정은 그대로 두고, 이번 한 번만 다른 계정으로 실행할 수도 있습니다:
+
+```bash
+cxs run 회사용            # 회사용 계정으로 codex 대화형 실행
+cxs run 회사용 exec "..."  # 회사용 계정으로 codex exec 실행
+```
+
+각 계정은 격리된 자기만의 환경에서 실행되므로, **터미널 2개를 열어 서로 다른 계정으로 동시에 codex를 돌릴 수도 있습니다.** (설정과 세션 기록은 공유됩니다.)
+
+---
+
+## 4. 명령어 전체 목록
+
+| 명령 | 설명 |
+|---|---|
+| `cxs login [이름]` | 새 계정 로그인 후 저장 (기존 로그인 유지, 이름 생략 시 이메일 사용) |
+| `cxs import [이름]` | 현재 `~/.codex`에 로그인된 계정을 저장소로 가져오기 |
+| `cxs list` | 계정 목록: 활성 표시(`*`), 이메일, 플랜, 우선순위, 한도 상태 |
+| `cxs use <이름>` | 활성 계정 전환 |
+| `cxs current` | 현재 활성 계정 확인 |
+| `cxs next` | 다음 사용 가능한 계정으로 순환 전환 |
+| `cxs run [이름] [인자...]` | 전환 없이 특정 계정으로 codex 실행 (격리 환경) |
+| `cxs exec [인자...]` | `codex exec` + 한도 도달 시 자동 계정 로테이션 |
+| `cxs exec -a <이름> ...` | 특정 계정부터 exec 시작 |
+| `cxs remove <이름>` | 계정 삭제 |
+| `cxs rename <옛이름> <새이름>` | 계정 이름 변경 |
+| `cxs disable / enable <이름>` | 로테이션에서 임시 제외 / 복귀 |
+| `cxs priority <이름> <숫자>` | 로테이션 우선순위 (낮을수록 먼저, 기본 0) |
+| `cxs clear-limit <이름>` | 기록된 한도 상태 수동 해제 |
+| `cxs cooldown [분]` | 한도 감지 시 기본 대기 시간 조회/설정 (기본 60분) |
+| `cxs sync` | codex가 갱신한 토큰을 저장소에 반영 |
+
+---
+
+## 5. 자주 묻는 질문 / 문제 해결
+
+**Q. `codexswitch: command not found` (또는 "인식할 수 없는 명령") 이 떠요.**
+npm 전역 설치 경로가 PATH에 없는 경우입니다. 터미널/PowerShell을 **완전히 닫았다 다시 열어보세요.** 그래도 안 되면 `npm config get prefix`로 나온 경로(Windows는 그 경로 자체, macOS는 그 아래 `bin` 폴더)를 PATH에 추가하세요.
+
+**Q. macOS에서 `npm install -g` 하다가 `EACCES` 권한 오류가 나요.**
+`sudo npm install -g @carjms/codexswitch`로 설치하거나, 더 좋은 방법으로는 [nvm](https://github.com/nvm-sh/nvm)으로 Node.js를 설치하면 권한 문제가 사라집니다.
+
+**Q. `codex CLI not found` 오류가 나요.**
+Codex CLI가 설치되지 않았거나 PATH에 없는 경우입니다. `npm install -g @openai/codex` 후 다시 시도하세요. 특별한 위치에 설치했다면 환경변수 `CODEX_SWITCH_CODEX_BIN`에 전체 경로를 지정하면 됩니다.
+
+**Q. 계정을 전환하면 기존 대화 세션이나 설정이 날아가나요?**
+아니요. 전환되는 것은 **인증 정보(auth.json)뿐**입니다. `config.toml` 설정, 세션 기록, 스킬 등은 모든 계정이 공유합니다.
+
+**Q. Windows에서 `run`/`exec`가 잘 동작하나요?**
+동작합니다. 내부적으로 macOS/Linux는 심볼릭 링크, Windows는 디렉토리 정션(관리자 권한 불필요)을 사용합니다. 파일 공유까지 완전하게 하려면 Windows **설정 → 개발자 모드**를 켜는 것을 추천하지만, 꺼져 있어도 복사 방식으로 자동 대체되어 문제없이 동작합니다.
+
+**Q. 한도에 걸렸다고 표시된 계정을 바로 다시 쓰고 싶어요.**
+`cxs clear-limit <이름>` 으로 해제하면 됩니다.
+
+**Q. 계정 이름에 한글을 써도 되나요?**
+네. `회사용`, `개인용` 같은 한글 이름 모두 가능합니다. (허용 문자: 한글 등 모든 언어의 글자, 숫자, 공백, `@ . _ + -`)
+
+**Q. 여러 계정을 쓰는 게 약관에 문제되지 않나요?**
+본인 소유의 정당한 계정들(예: 개인 계정과 회사 계정)을 전환하는 용도로 사용하세요. 한도 우회를 목적으로 한 계정 남용은 OpenAI 이용약관에 어긋날 수 있으며, 사용에 대한 책임은 사용자에게 있습니다.
+
+---
+
+## 6. 데이터가 저장되는 위치
+
+| 항목 | macOS/Linux | Windows |
+|---|---|---|
+| 계정 저장소 | `~/.codex-switch/` | `C:\Users\<사용자>\.codex-switch\` |
+| Codex 설정 | `~/.codex/` | `C:\Users\<사용자>\.codex\` |
+
+```
+.codex-switch/
+├── meta.json              # 활성 계정, 우선순위, 한도 상태, 쿨다운 설정
+├── accounts/<이름>.json    # 계정별 인증 정보 사본 (권한 600)
+└── profiles/<이름>/        # run/exec용 계정별 격리 실행 환경
+```
+
+### 환경변수로 위치 바꾸기
+
+| 변수 | 기본값 | 설명 |
+|---|---|---|
+| `CODEX_SWITCH_HOME` | `~/.codex-switch` | 계정 저장소 위치 |
+| `CODEX_HOME` | `~/.codex` | 관리 대상 codex 설정 디렉토리 |
+| `CODEX_SWITCH_CODEX_BIN` | `codex` | codex 바이너리 경로 |
+
+- macOS/Linux: `export CODEX_SWITCH_HOME=/원하는/경로`
+- Windows PowerShell: `$env:CODEX_SWITCH_HOME = "D:\원하는\경로"` (영구 설정은 `setx CODEX_SWITCH_HOME "D:\원하는\경로"`)
+
+---
+
+## 7. 설계 (어떻게 동작하나)
+
+### 핵심 아이디어 3가지
+
+**1. 계정 전환 = auth.json 교체 (`use`)**
+Codex CLI는 인증을 `auth.json` 파일 하나로 관리합니다. 저장해둔 계정별 사본을 원자적(atomic rename)으로 써넣는 것만으로 계정이 바뀌고, 설정·세션·히스토리는 그대로 유지됩니다.
+
+**2. 오버레이 프로필 = 전환 없는 격리 실행 (`run` / `exec`)**
+Codex CLI는 `CODEX_HOME` 환경변수로 설정 디렉토리를 바꿀 수 있습니다. 계정마다 프로필 디렉토리를 만들되 `auth.json`만 실제 파일로 두고, 나머지(`config.toml`, `sessions/`, `skills/` 등)는 실제 `~/.codex`로 연결(macOS/Linux: 심볼릭 링크, Windows: 정션/복사)합니다. 설정과 세션은 공유하면서 인증만 격리되므로 서로 다른 계정으로 동시 실행이 가능합니다. (sqlite 파일은 동시 접근 시 손상 위험이 있어 공유하지 않습니다.)
+
+**3. 한도 기반 자동 로테이션 (`exec`)** — teamclaude의 핵심 개념
+`codex exec`의 출력을 실시간으로 흘려보내면서 동시에 수집해 `usage limit / rate limit / 429` 패턴을 감지합니다. 감지되면 해당 계정을 쿨다운 처리(에러 메시지의 "try again in N hours" 파싱, 실패 시 기본 60분)하고, 우선순위 순으로 다음 계정을 골라 같은 명령을 재시도합니다. 한도가 아닌 일반 오류는 로테이션하지 않고 그대로 종료 코드를 전달합니다.
+
+### 토큰 수명 관리
+
+codex는 실행 중 스스로 토큰을 갱신해 `auth.json`을 다시 씁니다. 갱신본이 유실되지 않도록 계정 전환 직전과 `run`/`exec` 종료 시점에 현재 auth.json을 저장소로 **sync-back**합니다 (토큰의 `account_id`로 매칭, `last_refresh`가 최신일 때만 덮어씀).
+
+### 보안
+
+- 인증 파일은 권한 `600`, 디렉토리는 `700`으로 생성 (macOS/Linux)
+- 토큰을 화면에 출력하지 않음 — JWT는 이메일/플랜 표시용으로만 로컬 디코딩
+- 네트워크 요청 없음 — 모든 인증/갱신은 codex CLI 자신이 수행
+
+### teamclaude와의 차이
+
+teamclaude는 로컬 MITM 프록시로 API 트래픽을 가로채 할당량을 실시간 추적하며 요청 단위로 계정을 바꿉니다. Codex CLI는 할당량 조회를 외부에 노출하지 않으므로, codexswitch는 프록시 대신 **프로필 전환 + 출력 감지 기반의 명령 단위 로테이션**이라는 더 단순하고 안전한 방식을 택했습니다.
+
+---
+
+## 개발
+
+```bash
+git clone https://github.com/JIMyungSik/codexswitch.git
+cd codexswitch
+npm link       # 로컬 개발 버전을 전역 명령으로 연결
+npm test       # 가짜 codex 바이너리로 전체 흐름 검증 (실제 ~/.codex는 건드리지 않음)
+```
+
+## 라이선스
+
+MIT

package/bin/codex-switch.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+'use strict';
+
+require('../src/cli.js').main(process.argv.slice(2)).then(
+  (code) => process.exit(code || 0),
+  (err) => {
+    console.error(`error: ${err && err.message ? err.message : err}`);
+    process.exit(1);
+  }
+);

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@carjms/codexswitch",
+  "version": "0.1.0",
+  "description": "Multi-account manager for OpenAI Codex CLI with quota-based rotation (inspired by KarpelesLab/teamclaude)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JIMyungSik/codexswitch.git"
+  },
+  "homepage": "https://github.com/JIMyungSik/codexswitch#readme",
+  "bugs": {
+    "url": "https://github.com/JIMyungSik/codexswitch/issues"
+  },
+  "keywords": ["codex", "openai", "cli", "multi-account", "account-switcher", "rotation"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "bin": {
+    "codexswitch": "bin/codex-switch.js",
+    "cxs": "bin/codex-switch.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node test/smoke.test.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ]
+}

package/src/cli.js

@@ -0,0 +1,355 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { readJSONSafe, writeJSONAtomic, authInfo, ensureDir, fmtDate, fmtRemaining, table } = require('./util.js');
+const store = require('./store.js');
+const runner = require('./runner.js');
+
+const HELP = `codexswitch — multi-account manager for the OpenAI Codex CLI
+
+Accounts
+  login [name]            log in to a new account (isolated "codex login") and store it
+  import [name]           import the account currently in ~/.codex/auth.json
+  list                    list stored accounts (alias: accounts, status)
+  use <name>              make <name> the active account in ~/.codex
+  current                 show the active account
+  next                    rotate to the next usable account
+  remove <name>           delete a stored account
+  rename <old> <new>      rename a stored account
+  enable <name>           re-enable a disabled account
+  disable <name>          temporarily exclude an account from rotation
+  priority <name> <n>     set rotation priority (lower = preferred, default 0)
+  clear-limit <name>      forget a recorded rate-limit for an account
+
+Running codex
+  run [name] [args...]    run codex as <name> (or active account) in an isolated
+                          per-account CODEX_HOME; config/sessions are shared
+  exec [args...]          run "codex exec ..." and auto-rotate to the next
+                          account when a usage/rate limit is hit
+      -a, --account <n>   start exec with a specific account
+
+Maintenance
+  sync                    save tokens refreshed by codex back into the store
+  cooldown [minutes]      show/set rate-limit cooldown (default 60)
+  help                    show this help
+
+Environment
+  CODEX_SWITCH_HOME       data dir (default ~/.codex-switch)
+  CODEX_HOME              codex config dir codexswitch manages (default ~/.codex)
+  CODEX_SWITCH_CODEX_BIN  path to the codex binary (default "codex" on PATH)`;
+
+function out(msg) {
+  console.log(msg);
+}
+
+function requireArg(args, i, what) {
+  if (args[i] == null) throw new Error(`missing ${what} (see "codexswitch help")`);
+  return args[i];
+}
+
+function defaultName(auth) {
+  const info = authInfo(auth);
+  if (!info.email || info.email === '(api key)') {
+    throw new Error('could not derive an account name from the token; pass a name explicitly');
+  }
+  return info.email;
+}
+
+function storeAccount(name, auth) {
+  store.ensureDirs();
+  const info = authInfo(auth);
+  if (!info.accountId && !auth.OPENAI_API_KEY) {
+    throw new Error('auth.json has neither OAuth tokens nor an API key — refusing to import');
+  }
+  const existed = store.accountExists(name);
+  store.writeAccountAuth(name, auth);
+  const meta = store.loadMeta();
+  if (!meta.accounts[name]) meta.accounts[name] = { priority: 0, addedAt: Date.now() };
+  store.saveMeta(meta);
+  out(`${existed ? 'updated' : 'added'} account "${name}"${info.email ? ` (${info.email}, ${info.plan || 'unknown plan'})` : ''}`);
+  return name;
+}
+
+function cmdImport(args) {
+  const p = store.paths();
+  const auth = readJSONSafe(p.authPath);
+  if (!auth) throw new Error(`no auth.json found at ${p.authPath} — run "codex login" first`);
+  const name = args[0] || defaultName(auth);
+  storeAccount(name, auth);
+  const meta = store.loadMeta();
+  if (!meta.active) {
+    meta.active = name;
+    store.saveMeta(meta);
+    out(`set "${name}" as the active account`);
+  }
+}
+
+function cmdLogin(args) {
+  runner.assertCodexAvailable();
+  store.ensureDirs();
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'codexswitch-login-'));
+  try {
+    out('opening codex login in an isolated profile (your current account is untouched)...');
+    const r = runner.spawnCodexSync(['login'], {
+      env: { ...process.env, CODEX_HOME: tmp },
+      stdio: 'inherit',
+    });
+    if (r.status !== 0) throw new Error(`codex login exited with status ${r.status}`);
+    const auth = readJSONSafe(path.join(tmp, 'auth.json'));
+    if (!auth) throw new Error('login finished but no auth.json was produced');
+    const name = args[0] || defaultName(auth);
+    storeAccount(name, auth);
+    const meta = store.loadMeta();
+    if (!meta.active) {
+      cmdUse([name]);
+    } else {
+      out(`stored. activate it with: codexswitch use ${name}`);
+    }
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+function cmdList() {
+  const accounts = store.listAccounts();
+  if (accounts.length === 0) {
+    out('no accounts yet — add one with "codexswitch login" or "codexswitch import"');
+    return;
+  }
+  const now = Date.now();
+  const rows = accounts.map((a) => [
+    a.active ? '*' : '',
+    a.name,
+    a.email,
+    a.plan,
+    a.priority,
+    a.disabled ? 'disabled' : a.limitedUntil && a.limitedUntil > now ? `limited ${fmtRemaining(a.limitedUntil)}` : 'ok',
+    fmtDate(a.lastRefresh),
+  ]);
+  out(table(rows, ['', 'name', 'email', 'plan', 'prio', 'status', 'token refreshed']));
+}
+
+function cmdUse(args) {
+  const name = requireArg(args, 0, 'account name');
+  const auth = store.readAccountAuth(name);
+  store.syncBack(); // keep refreshed tokens of the outgoing account
+  const p = store.paths();
+  ensureDir(p.codexHome);
+  writeJSONAtomic(p.authPath, auth, 0o600);
+  const meta = store.loadMeta();
+  meta.active = name;
+  if (!meta.accounts[name]) meta.accounts[name] = { priority: 0 };
+  meta.accounts[name].lastUsed = Date.now();
+  store.saveMeta(meta);
+  const info = authInfo(auth);
+  out(`now using "${name}"${info.email ? ` (${info.email}, ${info.plan || 'unknown plan'})` : ''}`);
+}
+
+function cmdCurrent() {
+  const meta = store.loadMeta();
+  const p = store.paths();
+  const live = readJSONSafe(p.authPath);
+  if (!live) {
+    out(`no auth.json at ${p.authPath}`);
+    return;
+  }
+  const info = authInfo(live);
+  const match = store.listAccounts().find((a) => a.accountId === info.accountId);
+  const name = match ? match.name : '(not stored — run "codexswitch import")';
+  const note = meta.active && match && meta.active !== match.name ? ` (meta says "${meta.active}" — out of sync)` : '';
+  out(`active: ${name}${note}`);
+  out(`  email: ${info.email || '-'}\n  plan:  ${info.plan || '-'}\n  token refreshed: ${fmtDate(info.lastRefresh)}`);
+}
+
+function cmdNext() {
+  const meta = store.loadMeta();
+  const next = store.pickAccount(meta.active ? [meta.active] : []);
+  if (!next) throw new Error('no other usable account available');
+  cmdUse([next.name]);
+}
+
+function cmdRemove(args) {
+  const name = requireArg(args, 0, 'account name');
+  if (!store.accountExists(name)) throw new Error(`no such account: ${name}`);
+  fs.rmSync(store.accountPath(name), { force: true });
+  fs.rmSync(path.join(store.paths().profilesDir, name), { recursive: true, force: true });
+  const meta = store.loadMeta();
+  delete meta.accounts[name];
+  if (meta.active === name) meta.active = null;
+  store.saveMeta(meta);
+  out(`removed "${name}"`);
+}
+
+function cmdRename(args) {
+  const from = requireArg(args, 0, 'current name');
+  const to = requireArg(args, 1, 'new name');
+  const auth = store.readAccountAuth(from);
+  if (store.accountExists(to)) throw new Error(`account "${to}" already exists`);
+  store.writeAccountAuth(to, auth);
+  fs.rmSync(store.accountPath(from), { force: true });
+  const meta = store.loadMeta();
+  meta.accounts[to] = meta.accounts[from] || { priority: 0 };
+  delete meta.accounts[from];
+  if (meta.active === from) meta.active = to;
+  store.saveMeta(meta);
+  out(`renamed "${from}" -> "${to}"`);
+}
+
+function setFlag(name, patch) {
+  if (!store.accountExists(name)) throw new Error(`no such account: ${name}`);
+  const meta = store.loadMeta();
+  meta.accounts[name] = { ...(meta.accounts[name] || {}), ...patch };
+  store.saveMeta(meta);
+}
+
+function cmdPriority(args) {
+  const name = requireArg(args, 0, 'account name');
+  const n = parseInt(requireArg(args, 1, 'priority number'), 10);
+  if (Number.isNaN(n)) throw new Error('priority must be a number');
+  setFlag(name, { priority: n });
+  out(`priority of "${name}" set to ${n}`);
+}
+
+function cmdCooldown(args) {
+  const meta = store.loadMeta();
+  if (args[0] == null) {
+    out(`cooldown: ${meta.cooldownMinutes} minutes`);
+    return;
+  }
+  const n = parseInt(args[0], 10);
+  if (Number.isNaN(n) || n <= 0) throw new Error('cooldown must be a positive number of minutes');
+  meta.cooldownMinutes = n;
+  store.saveMeta(meta);
+  out(`cooldown set to ${n} minutes`);
+}
+
+function cmdSync() {
+  const updated = store.syncBack();
+  out(updated ? `synced refreshed tokens into "${updated}"` : 'nothing to sync');
+}
+
+async function cmdRun(args) {
+  let name = null;
+  let rest = args;
+  if (args[0] && store.accountExists(args[0])) {
+    name = args[0];
+    rest = args.slice(1);
+  }
+  if (!name) {
+    const meta = store.loadMeta();
+    const picked = store.pickAccount();
+    if (!picked) throw new Error('no usable account — add one with "codexswitch login"');
+    name = meta.active && store.accountExists(meta.active) ? meta.active : picked.name;
+  }
+  if (rest[0] === '--') rest = rest.slice(1);
+  out(`[codexswitch] running codex as "${name}"`);
+  const res = await runner.runCodex(name, rest);
+  return res.code;
+}
+
+async function cmdExec(args) {
+  let explicit = null;
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-a' || args[i] === '--account') {
+      explicit = requireArg(args, ++i, 'account name after --account');
+    } else {
+      rest.push(args[i]);
+    }
+  }
+  if (explicit && !store.accountExists(explicit)) throw new Error(`no such account: ${explicit}`);
+
+  const meta = store.loadMeta();
+  const total = store.listAccounts().length;
+  if (total === 0) throw new Error('no accounts — add one with "codexswitch login"');
+
+  const tried = [];
+  for (let attempt = 0; attempt < total; attempt++) {
+    let name;
+    if (explicit && attempt === 0) {
+      name = explicit;
+    } else {
+      const picked = store.pickAccount(tried);
+      if (!picked) break;
+      name = picked.name;
+    }
+    tried.push(name);
+    console.error(`[codexswitch] exec as "${name}"${attempt > 0 ? ` (attempt ${attempt + 1})` : ''}`);
+    const res = await runner.runCodex(name, ['exec', ...rest], { capture: true });
+    if (res.code === 0) {
+      store.clearLimited(name);
+      return 0;
+    }
+    if (runner.looksRateLimited(res.output)) {
+      const until = Date.now() + runner.limitCooldownMs(res.output, meta.cooldownMinutes);
+      store.markLimited(name, until);
+      console.error(`[codexswitch] "${name}" hit a usage/rate limit (paused until ${fmtDate(until)}) — rotating`);
+      continue;
+    }
+    return res.code; // real failure, don't burn other accounts on it
+  }
+  console.error('[codexswitch] all accounts are rate-limited or disabled');
+  return 2;
+}
+
+async function main(argv) {
+  const [cmd, ...args] = argv;
+  switch (cmd) {
+    case undefined:
+    case 'help':
+    case '--help':
+    case '-h':
+      out(HELP);
+      return 0;
+    case 'login':
+      return cmdLogin(args), 0;
+    case 'import':
+      return cmdImport(args), 0;
+    case 'list':
+    case 'accounts':
+    case 'status':
+      return cmdList(), 0;
+    case 'use':
+      return cmdUse(args), 0;
+    case 'current':
+    case 'whoami':
+      return cmdCurrent(), 0;
+    case 'next':
+      return cmdNext(), 0;
+    case 'remove':
+    case 'rm':
+      return cmdRemove(args), 0;
+    case 'rename':
+      return cmdRename(args), 0;
+    case 'enable':
+      setFlag(requireArg(args, 0, 'account name'), { disabled: false });
+      out(`enabled "${args[0]}"`);
+      return 0;
+    case 'disable':
+      setFlag(requireArg(args, 0, 'account name'), { disabled: true });
+      out(`disabled "${args[0]}"`);
+      return 0;
+    case 'priority':
+      return cmdPriority(args), 0;
+    case 'clear-limit': {
+      const name = requireArg(args, 0, 'account name');
+      store.clearLimited(name);
+      out(`cleared rate-limit record for "${name}"`);
+      return 0;
+    }
+    case 'cooldown':
+      return cmdCooldown(args), 0;
+    case 'sync':
+      return cmdSync(), 0;
+    case 'run':
+      return cmdRun(args);
+    case 'exec':
+      return cmdExec(args);
+    default:
+      throw new Error(`unknown command "${cmd}" (see "codexswitch help")`);
+  }
+}
+
+module.exports = { main };

package/src/runner.js

@@ -0,0 +1,223 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+const { ensureDir, parseDurationMs } = require('./util.js');
+const store = require('./store.js');
+
+let cachedBin = null;
+
+// Resolve the codex binary. On Windows an npm-installed codex is usually a
+// "codex.cmd" shim which Node refuses to spawn directly (EINVAL), so resolve
+// the real path via `where` and prefer a native .exe when one exists.
+function codexBin() {
+  if (process.env.CODEX_SWITCH_CODEX_BIN) return process.env.CODEX_SWITCH_CODEX_BIN;
+  if (cachedBin) return cachedBin;
+  cachedBin = 'codex';
+  if (process.platform === 'win32') {
+    const r = spawnSync('where', ['codex'], { encoding: 'utf8' });
+    if (r.status === 0 && r.stdout) {
+      const lines = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+      cachedBin = lines.find((l) => /\.exe$/i.test(l)) || lines[0] || 'codex';
+    }
+  }
+  return cachedBin;
+}
+
+// cmd.exe argument quoting for the .cmd/.bat shim case (shell: true).
+function winQuote(arg) {
+  if (arg === '') return '""';
+  if (!/[\s"^&|<>()%!;,=]/.test(arg)) return arg;
+  return '"' + arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, '$1$1') + '"';
+}
+
+// Node cannot spawn .cmd/.bat files without a shell; wrap args accordingly.
+function spawnPlan(args) {
+  const bin = codexBin();
+  if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(bin)) {
+    return { bin: winQuote(bin), args: args.map(winQuote), shell: true };
+  }
+  return { bin, args, shell: false };
+}
+
+function spawnCodexSync(args, options = {}) {
+  const plan = spawnPlan(args);
+  return spawnSync(plan.bin, plan.args, { ...options, shell: plan.shell });
+}
+
+function assertCodexAvailable() {
+  const r = spawnCodexSync(['--version'], { stdio: 'ignore' });
+  if ((r.error && r.error.code === 'ENOENT') || r.status === 127) {
+    throw new Error(
+      `codex CLI not found ("${codexBin()}"). Install it with "npm install -g @openai/codex" or set CODEX_SWITCH_CODEX_BIN to its path.`
+    );
+  }
+}
+
+// Build a per-account CODEX_HOME overlay: every top-level entry of the real
+// CODEX_HOME is symlinked into the profile so config, sessions, skills and
+// history are shared — except auth.json (per-account, copied from the store)
+// and sqlite databases (excluded: two codex processes writing the same
+// sqlite file through symlinks risks corruption; each profile keeps its own).
+function buildProfile(name) {
+  const p = store.paths();
+  const profile = path.join(p.profilesDir, name);
+  ensureDir(profile);
+
+  let entries = [];
+  try {
+    entries = fs.readdirSync(p.codexHome);
+  } catch {
+    /* no real codex home yet — profile starts empty */
+  }
+
+  // Drop stale symlinks (target removed, or entry no longer shareable).
+  for (const entry of fs.readdirSync(profile)) {
+    const dest = path.join(profile, entry);
+    let st;
+    try {
+      st = fs.lstatSync(dest);
+    } catch {
+      continue;
+    }
+    if (!st.isSymbolicLink()) continue;
+    const shouldExist = entries.includes(entry) && shareable(entry);
+    if (!shouldExist || !fs.existsSync(dest)) fs.rmSync(dest, { force: true });
+  }
+
+  for (const entry of entries) {
+    if (!shareable(entry)) continue;
+    const dest = path.join(profile, entry);
+    const target = path.join(p.codexHome, entry);
+    if (isLink(dest)) continue;
+    if (fs.existsSync(dest)) {
+      // Windows copy fallback: refresh the copy when the original changed.
+      if (process.platform === 'win32') refreshCopy(target, dest);
+      continue;
+    }
+    linkEntry(target, dest);
+  }
+
+  const auth = store.readAccountAuth(name);
+  const authFile = path.join(profile, 'auth.json');
+  fs.writeFileSync(authFile, JSON.stringify(auth, null, 2) + '\n', { mode: 0o600 });
+  return profile;
+}
+
+function shareable(entry) {
+  if (entry === 'auth.json') return false;
+  if (/\.sqlite(-wal|-shm|-journal)?$/.test(entry)) return false;
+  if (entry === 'tmp') return false;
+  return true;
+}
+
+function isLink(file) {
+  try {
+    return fs.lstatSync(file).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+// Share one entry into the profile. POSIX: plain symlink. Windows: junction
+// for directories (no admin required); for files try a symlink (works with
+// Developer Mode) and fall back to a plain copy.
+function linkEntry(target, dest) {
+  let isDir = false;
+  try {
+    isDir = fs.statSync(target).isDirectory();
+  } catch {
+    return;
+  }
+  if (process.platform !== 'win32') {
+    fs.symlinkSync(target, dest);
+    return;
+  }
+  try {
+    fs.symlinkSync(target, dest, isDir ? 'junction' : 'file');
+  } catch {
+    if (!isDir) {
+      try {
+        fs.copyFileSync(target, dest);
+      } catch {
+        /* unshareable entry — codex will recreate what it needs */
+      }
+    }
+  }
+}
+
+function refreshCopy(target, dest) {
+  try {
+    const s = fs.statSync(target);
+    const d = fs.statSync(dest);
+    if (s.isFile() && d.isFile() && s.mtimeMs > d.mtimeMs) fs.copyFileSync(target, dest);
+  } catch {
+    /* best effort */
+  }
+}
+
+// Run codex for one account inside its overlay profile.
+// capture=false: interactive, stdio inherited. capture=true: stream output
+// through while also collecting it so the caller can detect limit errors.
+function runCodex(name, args, { capture = false } = {}) {
+  assertCodexAvailable();
+  const profile = buildProfile(name);
+  const env = { ...process.env, CODEX_HOME: profile };
+
+  return new Promise((resolve) => {
+    const plan = spawnPlan(args);
+    const child = spawn(plan.bin, plan.args, {
+      env,
+      shell: plan.shell,
+      stdio: capture ? ['inherit', 'pipe', 'pipe'] : 'inherit',
+    });
+    let out = '';
+    if (capture) {
+      const collect = (stream, dest) => {
+        stream.on('data', (chunk) => {
+          out += chunk.toString('utf8');
+          if (out.length > 262144) out = out.slice(-131072);
+          dest.write(chunk);
+        });
+      };
+      collect(child.stdout, process.stdout);
+      collect(child.stderr, process.stderr);
+    }
+    child.on('error', (err) => resolve({ code: 1, output: out, error: err }));
+    child.on('close', (code) => {
+      // codex may have refreshed the token while running — persist it.
+      try {
+        store.syncBackFrom(path.join(profile, 'auth.json'));
+      } catch {
+        /* best effort */
+      }
+      resolve({ code: code == null ? 1 : code, output: out });
+    });
+  });
+}
+
+const LIMIT_RE =
+  /usage limit|rate limit|too many requests|quota (?:exceeded|reached)|\b429\b|hit your (?:usage|weekly|5h) limit/i;
+
+function looksRateLimited(output) {
+  return LIMIT_RE.test(output || '');
+}
+
+// Try to extract "try again in 2 hours 30 minutes" style hints; fall back
+// to the configured cooldown.
+function limitCooldownMs(output, cooldownMinutes) {
+  const m = /try again (?:in|after)\s+([^.\n]+)/i.exec(output || '');
+  const parsed = m ? parseDurationMs(m[1]) : null;
+  return parsed || cooldownMinutes * 60000;
+}
+
+module.exports = {
+  codexBin,
+  spawnCodexSync,
+  assertCodexAvailable,
+  buildProfile,
+  runCodex,
+  looksRateLimited,
+  limitCooldownMs,
+};

package/src/store.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { ensureDir, readJSON, readJSONSafe, writeJSONAtomic, authInfo } = require('./util.js');
+
+// Directory layout:
+//   ~/.codex-switch/
+//     meta.json          account registry (priority/disabled/limits) + active name
+//     accounts/<name>.json   stored copy of that account's codex auth.json
+//     profiles/<name>/       per-account CODEX_HOME overlay used by `run`/`exec`
+// Overridable for tests / custom setups via CODEX_SWITCH_HOME.
+function paths() {
+  const home = process.env.CODEX_SWITCH_HOME || path.join(os.homedir(), '.codex-switch');
+  const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  return {
+    home,
+    codexHome,
+    accountsDir: path.join(home, 'accounts'),
+    profilesDir: path.join(home, 'profiles'),
+    metaPath: path.join(home, 'meta.json'),
+    authPath: path.join(codexHome, 'auth.json'),
+  };
+}
+
+function loadMeta() {
+  const p = paths();
+  const meta = readJSONSafe(p.metaPath, {}) || {};
+  if (!meta.accounts) meta.accounts = {};
+  if (!('active' in meta)) meta.active = null;
+  if (!meta.cooldownMinutes) meta.cooldownMinutes = 60;
+  return meta;
+}
+
+function saveMeta(meta) {
+  writeJSONAtomic(paths().metaPath, meta);
+}
+
+function accountPath(name) {
+  // Unicode letters/digits are fine (names become filenames); block path
+  // separators, traversal, and characters invalid on Windows filesystems.
+  if (!/^[\p{L}\p{N}@._+ -]+$/u.test(name) || name.includes('..') || /^[. ]|[. ]$/.test(name)) {
+    throw new Error(`invalid account name "${name}" (letters, digits, spaces, @ . _ + - only)`);
+  }
+  return path.join(paths().accountsDir, `${name}.json`);
+}
+
+function accountExists(name) {
+  try {
+    return fs.existsSync(accountPath(name));
+  } catch {
+    return false;
+  }
+}
+
+function readAccountAuth(name) {
+  if (!accountExists(name)) throw new Error(`no such account: ${name} (see "codexswitch list")`);
+  return readJSON(accountPath(name));
+}
+
+function writeAccountAuth(name, auth) {
+  writeJSONAtomic(accountPath(name), auth, 0o600);
+}
+
+function listAccounts() {
+  const p = paths();
+  const meta = loadMeta();
+  let files = [];
+  try {
+    files = fs.readdirSync(p.accountsDir).filter((f) => f.endsWith('.json'));
+  } catch {
+    /* no accounts yet */
+  }
+  return files
+    .map((f) => {
+      const name = f.slice(0, -5);
+      const auth = readJSONSafe(path.join(p.accountsDir, f));
+      const m = meta.accounts[name] || {};
+      return {
+        name,
+        ...authInfo(auth),
+        priority: m.priority ?? 0,
+        disabled: !!m.disabled,
+        limitedUntil: m.limitedUntil || null,
+        active: meta.active === name,
+      };
+    })
+    .sort((a, b) => a.priority - b.priority || a.name.localeCompare(b.name));
+}
+
+// Copy refreshed tokens from a live auth.json back into the store, so a
+// token refresh done by codex itself is never lost when we switch accounts.
+// Matches by account_id; prefers the account we believe deployed the file.
+function syncBackFrom(authFile) {
+  const cur = readJSONSafe(authFile);
+  if (!cur) return null;
+  const curInfo = authInfo(cur);
+  if (!curInfo.accountId) return null;
+  const meta = loadMeta();
+  const candidates = listAccounts().filter((a) => a.accountId === curInfo.accountId);
+  if (candidates.length === 0) return null;
+  const target = candidates.find((a) => a.name === meta.active) || candidates[0];
+  const stored = readAccountAuth(target.name);
+  const newer =
+    !stored.last_refresh || (cur.last_refresh && cur.last_refresh > stored.last_refresh);
+  if (newer && JSON.stringify(stored) !== JSON.stringify(cur)) {
+    writeAccountAuth(target.name, cur);
+    return target.name;
+  }
+  return null;
+}
+
+function syncBack() {
+  return syncBackFrom(paths().authPath);
+}
+
+function markLimited(name, untilTs) {
+  const meta = loadMeta();
+  if (!meta.accounts[name]) meta.accounts[name] = {};
+  meta.accounts[name].limitedUntil = untilTs;
+  saveMeta(meta);
+}
+
+function clearLimited(name) {
+  const meta = loadMeta();
+  if (meta.accounts[name] && meta.accounts[name].limitedUntil) {
+    delete meta.accounts[name].limitedUntil;
+    saveMeta(meta);
+  }
+}
+
+// Pick the best usable account: enabled, not currently rate-limited,
+// lowest priority number first. `exclude` skips accounts already tried.
+function pickAccount(exclude = []) {
+  const now = Date.now();
+  const usable = listAccounts().filter(
+    (a) => !a.disabled && !exclude.includes(a.name) && (!a.limitedUntil || a.limitedUntil <= now)
+  );
+  if (usable.length === 0) return null;
+  const active = usable.find((a) => a.active);
+  return active || usable[0];
+}
+
+module.exports = {
+  paths,
+  loadMeta,
+  saveMeta,
+  accountPath,
+  accountExists,
+  readAccountAuth,
+  writeAccountAuth,
+  listAccounts,
+  syncBack,
+  syncBackFrom,
+  markLimited,
+  clearLimited,
+  pickAccount,
+  ensureDirs() {
+    const p = paths();
+    ensureDir(p.home);
+    ensureDir(p.accountsDir);
+    ensureDir(p.profilesDir);
+  },
+};

package/src/util.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function ensureDir(dir, mode = 0o700) {
+  fs.mkdirSync(dir, { recursive: true, mode });
+}
+
+function readJSON(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function readJSONSafe(file, fallback = null) {
+  try {
+    return readJSON(file);
+  } catch {
+    return fallback;
+  }
+}
+
+// Write JSON atomically (tmp file + rename) so a crash never leaves a
+// half-written auth/meta file behind.
+function writeJSONAtomic(file, data, mode = 0o600) {
+  ensureDir(path.dirname(file));
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode });
+  fs.renameSync(tmp, file);
+}
+
+// Decode a JWT payload without verifying the signature. We only use this to
+// display identity info (email, plan) that codex already trusts locally.
+function decodeJwtPayload(token) {
+  try {
+    const part = token.split('.')[1];
+    const pad = part + '='.repeat((4 - (part.length % 4)) % 4);
+    return JSON.parse(Buffer.from(pad, 'base64url').toString('utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// Extract display info from a codex auth.json object.
+function authInfo(auth) {
+  const info = { email: null, plan: null, accountId: null, lastRefresh: null };
+  if (!auth || typeof auth !== 'object') return info;
+  info.lastRefresh = auth.last_refresh || null;
+  const tokens = auth.tokens || {};
+  info.accountId = tokens.account_id || null;
+  const payload = tokens.id_token ? decodeJwtPayload(tokens.id_token) : null;
+  if (payload) {
+    info.email = payload.email || null;
+    const oa = payload['https://api.openai.com/auth'] || {};
+    info.plan = oa.chatgpt_plan_type || null;
+    if (!info.accountId) info.accountId = oa.chatgpt_account_id || null;
+  }
+  if (!info.email && auth.OPENAI_API_KEY) info.email = '(api key)';
+  return info;
+}
+
+// Parse durations like "2 hours 30 minutes", "5h", "3 days" into ms.
+function parseDurationMs(text) {
+  if (!text) return null;
+  let ms = 0;
+  const re = /(\d+(?:\.\d+)?)\s*(d(?:ays?)?|h(?:ours?|rs?)?|m(?:in(?:utes?)?)?|s(?:ec(?:onds?)?)?)\b/gi;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const n = parseFloat(m[1]);
+    const unit = m[2][0].toLowerCase();
+    ms += n * { d: 86400000, h: 3600000, m: 60000, s: 1000 }[unit];
+  }
+  return ms > 0 ? ms : null;
+}
+
+function fmtDate(ts) {
+  if (!ts) return '-';
+  const d = new Date(ts);
+  if (isNaN(d.getTime())) return String(ts);
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+function fmtRemaining(untilTs) {
+  const ms = untilTs - Date.now();
+  if (ms <= 0) return 'now';
+  const h = Math.floor(ms / 3600000);
+  const m = Math.round((ms % 3600000) / 60000);
+  return h > 0 ? `${h}h${m}m` : `${m}m`;
+}
+
+function table(rows, headers) {
+  const all = [headers, ...rows].map((r) => r.map((c) => String(c == null ? '-' : c)));
+  const widths = headers.map((_, i) => Math.max(...all.map((r) => r[i].length)));
+  const line = (r) => r.map((c, i) => c.padEnd(widths[i])).join('  ').trimEnd();
+  return [line(all[0]), line(widths.map((w) => '-'.repeat(w))), ...all.slice(1).map(line)].join('\n');
+}
+
+module.exports = {
+  ensureDir,
+  readJSON,
+  readJSONSafe,
+  writeJSONAtomic,
+  decodeJwtPayload,
+  authInfo,
+  parseDurationMs,
+  fmtDate,
+  fmtRemaining,
+  table,
+};