cchost 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Allen Benny
+
+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,115 @@
+# cchost
+
+Host multiple isolated Claude Code accounts on one machine via a single `cc` command. Works identically in PowerShell, cmd, bash, zsh, and fish on Windows, macOS, and Linux.
+
+Each profile is a complete, isolated `CLAUDE_CONFIG_DIR` — credentials, session history, project state, plugins, and settings. Create one with `cc add <name>`; launch under it with `cc use <name>`.
+
+## Install
+
+```
+npm install -g cchost
+```
+
+Requires Node.js 18+ and Claude Code 2.1.140+ already installed. Get Claude Code from <https://code.claude.com> (`npm install -g @anthropic-ai/claude-code`).
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `cc add <profile> [--email=] [--org=] [--name=]` | Create a profile directory. Optional alias flags (EXPERIMENTAL, see below). |
+| `cc use <profile> [...args]` | Launch Claude under that profile. Profile must already exist. Args after the name are forwarded verbatim to `claude`. |
+| `cc list [--original] [--json]` | Show every profile, login state, account email, active marker, and linked/isolated status. |
+| `cc current [--json]` | Print the active profile (`CC_ACTIVE_PROFILE`) or "no profile active". |
+| `cc migrate <src> <dest>` | Copy projects from `default`\|`shared` to `shared`\|`<profile>`. Skip-on-collision; credential files never copied. |
+| `cc link <profile> [<profile>...]` | Link a profile's `projects/` and `sessions/` to `~/.claude-shared`. Migrates existing content; renames on collision. |
+| `cc unlink <profile>` | Restore a profile to its own private `projects/` and `sessions/` (copies shared content back). |
+| `cc remove <profile>` | Delete a profile. Requires typing the profile name to confirm. |
+| `cc help [command]` | Print usage (top-level, or for a single command). |
+
+### Examples
+
+```bash
+cc add work                            # create the profile, do not launch
+cc use work                            # first launch: Claude prompts for login
+cc use work --resume                   # resume last conversation under "work"
+cc use personal -p "summarize"         # one-shot prompt under "personal"
+cc list
+cc current
+cc remove old-profile
+```
+
+### Migrating existing projects
+
+If you've been using Claude Code without profiles, your history lives in `~/.claude/projects/`. Pull it into a profile or the shared pool:
+
+```bash
+cc migrate default work        # copy ~/.claude/projects → ~/.claude-profiles/work/projects
+cc migrate default shared      # copy ~/.claude/projects → ~/.claude-shared/projects
+cc migrate shared personal     # copy ~/.claude-shared/projects → ~/.claude-profiles/personal/projects
+```
+
+This is a **copy** — the source is left untouched. If an entry already exists at the destination, the source entry is skipped (no overwrite). Credential files (`.credentials.json`, `.claude.json`) are never copied: each profile keeps its own auth state.
+
+### Shared history across profiles
+
+If you want each profile to keep separate credentials but share project history (e.g. rotate accounts on the same project when usage limits hit):
+
+```bash
+cc link work
+cc link personal
+cc list                        # the Linked column shows "linked" vs "isolated"
+```
+
+`work/projects` and `personal/projects` become links to `~/.claude-shared/projects`. Same for `sessions/`. On Windows this uses directory junctions (no admin/Developer Mode required); on macOS/Linux, regular symlinks.
+
+`cc link a b c` links several profiles at once; per-profile failures are reported but don't abort the rest of the batch.
+
+If two profiles share history and you launch them against the same project at the same time, both will write to the same session files (last write wins). Don't do that.
+
+`cc remove` is safe with shared profiles — it deletes only the link, never recursing into the shared target.
+
+### Aliases (`cc add` flags) — EXPERIMENTAL
+
+`cc add work --email=work@example.com --org=Acme --name="Work Account"` stores those values in `~/.claude-profiles/work/.cc-alias.json`. On every `cc use`, they're written into the profile's `.claude.json` `oauthAccount` so `cc list` and Claude's own UI display them instead of the real underlying account.
+
+**EXPERIMENTAL.** Claude Code may overwrite `oauthAccount` on server re-sync; we re-apply on the next `cc use`, but masking across all of Claude's UI surfaces has not been verified. Use `cc list --original` to see the real values from `.claude.json`.
+
+## How it works
+
+`cc` is a Node CLI with **zero runtime dependencies**. For `cc use` it:
+
+1. Resolves the profile directory under `~/.claude-profiles/<name>/`
+2. Applies any stored alias to `.claude.json` `oauthAccount` (best-effort)
+3. Sets `CLAUDE_CONFIG_DIR` and `CC_ACTIVE_PROFILE` in its **own** spawn environment
+4. Spawns `claude` with `stdio: 'inherit'` so the TUI works correctly
+5. Forwards the child's exit code
+
+The env vars are set on the child process only — that's all `claude` needs.
+
+## Sensitive data
+
+`~/.claude-profiles/<profile>/` holds real OAuth credentials. Treat it like SSH keys: don't commit it, don't share it, don't sync it to public cloud storage. The `.gitignore` shipped with this project excludes profile directories from anywhere they might land. `cc migrate` and `cc link` never copy `.credentials.json` or `.claude.json` across profiles.
+
+## Troubleshooting
+
+**`Claude Code does not appear to be installed`**
+Install it (`npm install -g @anthropic-ai/claude-code`) and make sure `claude --version` runs in a fresh terminal.
+
+**`warning: Claude Code <version> is older than 2.1.140`**
+Earlier versions had bugs where Windows read `.claude.json` from `%USERPROFILE%` regardless of `CLAUDE_CONFIG_DIR`, breaking isolation. Run `claude update`.
+
+**`Profile "<name>" does not exist. Create it with: cc add <name>`**
+`cc use` does not auto-create profiles — that prevents typos like `cc use wokr` from silently creating a new, blank one. Run `cc add <name>` first.
+
+**Profile name rejected**
+Names must be free of path separators, whitespace, `..`, leading dots, and reserved DOS names (CON, PRN, COM1…). Stick to letters, digits, dashes, underscores.
+
+**`cc current` says no profile is active inside a Claude session**
+That means `CC_ACTIVE_PROFILE` isn't set in your shell — `cc use` sets it on the spawned `claude`, so it's visible to nested `cc current` invocations but not in unrelated shells.
+
+**Old shell-script version was leaking keystrokes / leaking `use work` into the prompt**
+That was a known bug in the cmd-based predecessor (`%*` ignored `shift`). This package forwards only the argv after `<profile>` to `claude`; the action and profile name themselves are consumed by `cc`.
+
+## License
+
+MIT

package/bin/cc.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+'use strict';
+
+const { run } = require('../lib/cli');
+
+(async () => {
+  try {
+    const code = await run(process.argv.slice(2));
+    process.exit(typeof code === 'number' ? code : 0);
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    process.stderr.write(message + '\n');
+    const code = err && Number.isInteger(err.exitCode) ? err.exitCode : 1;
+    process.exit(code);
+  }
+})();

package/lib/cli.js

@@ -0,0 +1,458 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const profiles = require('./profiles');
+const share = require('./share');
+const migrateLib = require('./migrate');
+const { spawnClaude } = require('./spawn');
+const { renderTable } = require('./format');
+const color = require('./color');
+
+const HELP = `cc - Multi-profile launcher for Claude Code
+
+Usage:
+  cc add <profile> [--email=] [--org=] [--name=]   Create a profile (EXPERIMENTAL aliases)
+  cc use <profile> [...args]                       Launch Claude under a named profile
+  cc list [--original] [--json]                    Show all profiles, login state, email, active, linked
+  cc current [--json]                              Show the active profile (from CC_ACTIVE_PROFILE)
+  cc migrate <src> <dest>                          Copy projects from default|shared to shared|<profile>
+  cc link <p>...                                   Replace each profile's projects/sessions with links to shared
+  cc unlink <profile>                              Restore a profile's private projects/sessions
+  cc remove <profile>                              Delete a profile and all its data (typed confirmation)
+  cc help [command]                                Show usage (optionally for a single command)
+
+Profiles live in ~/.claude-profiles/<profile>/ and become CLAUDE_CONFIG_DIR
+for that launch. Args after the profile name are forwarded verbatim to claude.
+`;
+
+const HELP_BY_CMD = {
+  add: `cc add <profile> [--email=...] [--org=...] [--name=...]
+
+Create a new profile directory without launching Claude. Optional alias flags
+record account values shown in 'cc list' and written into the profile's
+.claude.json oauthAccount on subsequent 'cc use' launches.
+
+EXPERIMENTAL: Claude Code may overwrite these on server re-sync. Masking
+behavior across all UI surfaces has not been verified.
+
+Examples:
+  cc add work
+  cc add work --email=work@example.com --org=Acme --name="Work Account"
+`,
+  use: `cc use <profile> [...args]
+
+Launch Claude under a named profile. The profile must already exist (create
+it with 'cc add <profile>'). Its directory under ~/.claude-profiles/<profile>/
+becomes CLAUDE_CONFIG_DIR for the spawned claude — credentials, sessions,
+projects, plugins, and history are all isolated.
+
+All args after the profile name are forwarded verbatim to claude.
+
+Examples:
+  cc use work
+  cc use work --resume
+  cc use personal -p "summarize this codebase"
+`,
+  list: `cc list [--original] [--json]
+
+Show every profile under ~/.claude-profiles/, whether it has credentials, the
+account email, which one matches CC_ACTIVE_PROFILE, and whether the profile
+is linked to ~/.claude-shared.
+
+By default, the displayed email reflects any alias set via 'cc add'.
+With --original, shows the real value from .claude.json.
+
+With --json, emits an array of
+{name, dir, loggedIn, email, active, linked, shared:{projects, sessions}, alias}.
+`,
+  current: `cc current [--json]
+
+Print the value of CC_ACTIVE_PROFILE, or "no profile active" if it isn't set.
+CC_ACTIVE_PROFILE is set by 'cc use' on the spawned claude, so nested cc
+invocations see it.
+
+With --json, emits {profile, configDir} (both null when nothing is active).
+`,
+  migrate: `cc migrate <src> <dest>
+
+Copy projects/ (and sessions/ if present) from a source to a destination.
+This is a COPY — the source is left untouched.
+
+  <src>:   default | shared
+           default = ~/.claude/        (Claude's built-in non-profile data)
+           shared  = ~/.claude-shared/ (the cc shared pool)
+  <dest>:  shared | <profile-name>
+
+On collisions, existing entries at the destination are left alone (the source
+entry is skipped). Credential files (.credentials.json, .claude.json) are
+never copied — the destination keeps its own auth state.
+
+Examples:
+  cc migrate default work     # ~/.claude/projects -> ~/.claude-profiles/work/projects
+  cc migrate default shared   # ~/.claude/projects -> ~/.claude-shared/projects
+  cc migrate shared work      # ~/.claude-shared/projects -> ~/.claude-profiles/work/projects
+`,
+  link: `cc link <profile> [<profile>...]
+
+Replace each profile's projects/ and sessions/ with links to ~/.claude-shared.
+Existing content is migrated into shared first; collisions are renamed with a
+__<profile> suffix (never overwritten).
+
+On Windows, link uses directory junctions (no admin/Developer Mode needed).
+On macOS/Linux, regular symlinks.
+
+Multiple profiles can be linked at once: 'cc link a b c'. Per-profile failures
+are reported but don't abort the rest of the batch.
+`,
+  unlink: `cc unlink <profile>
+
+Remove a profile's links to ~/.claude-shared/ and copy shared content back
+into the profile as private dirs.
+`,
+  remove: `cc remove <profile>
+
+Delete a profile and everything inside its directory: credentials, sessions,
+projects, plugins, and history. To confirm, you must type the exact profile
+name — y/n is intentionally not accepted because credential loss is unrecoverable.
+
+If the profile's projects/ or sessions/ is a link to ~/.claude-shared/, only
+the link is removed — the shared target is preserved.
+`,
+  help: `cc help [command]
+
+Without an argument: print the summary of all commands.
+With a command name: print detail for just that command.
+`,
+};
+
+function usageError(msg) {
+  const e = new Error(msg);
+  e.exitCode = 2;
+  return e;
+}
+
+function printHelp(cmd) {
+  if (cmd && Object.prototype.hasOwnProperty.call(HELP_BY_CMD, cmd)) {
+    process.stdout.write(HELP_BY_CMD[cmd]);
+  } else {
+    process.stdout.write(HELP);
+  }
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+function isLinkLike(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function removeRecursivelyPreservingLinks(p) {
+  let st;
+  try {
+    st = fs.lstatSync(p);
+  } catch {
+    return;
+  }
+  if (st.isSymbolicLink()) {
+    try {
+      fs.unlinkSync(p);
+      return;
+    } catch (err) {
+      if (process.platform === 'win32') {
+        fs.rmdirSync(p);
+        return;
+      }
+      throw err;
+    }
+  }
+  if (st.isDirectory()) {
+    for (const ent of fs.readdirSync(p)) {
+      removeRecursivelyPreservingLinks(path.join(p, ent));
+    }
+    fs.rmdirSync(p);
+    return;
+  }
+  fs.unlinkSync(p);
+}
+
+function parseFlagsStrict(args, flagNames, { allowPositional = false } = {}) {
+  const flags = new Set();
+  const positional = [];
+  for (const a of args) {
+    if (a.startsWith('-')) {
+      if (!flagNames.includes(a)) {
+        throw usageError(`Unknown flag: ${a}`);
+      }
+      flags.add(a);
+    } else {
+      positional.push(a);
+    }
+  }
+  if (!allowPositional && positional.length > 0) {
+    throw usageError(`Unexpected argument: ${positional[0]}`);
+  }
+  return { flags, positional };
+}
+
+function parseAliasFlags(args) {
+  const out = {};
+  for (const a of args) {
+    if (!a.startsWith('--')) {
+      throw usageError(`Unexpected positional argument: ${a}`);
+    }
+    const eq = a.indexOf('=');
+    if (eq === -1) {
+      throw usageError(`Flag must be in --key=value form: ${a}`);
+    }
+    const key = a.slice(2, eq);
+    const value = a.slice(eq + 1);
+    if (!profiles.ALLOWED_ALIAS_KEYS.includes(key)) {
+      throw usageError(`Unknown flag: --${key}. Allowed: --email, --org, --name.`);
+    }
+    if (value.length === 0) {
+      throw usageError(`Flag --${key} requires a non-empty value.`);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+async function cmdAdd(rest) {
+  const [name, ...flagArgs] = rest;
+  if (!name) throw usageError('Usage: cc add <profile> [--email=...] [--org=...] [--name=...]');
+  const aliasFlags = parseAliasFlags(flagArgs);
+  const { dir } = profiles.addProfile(name, aliasFlags);
+  console.log(`Created profile "${name}" at ${dir}.`);
+  if (Object.keys(aliasFlags).length > 0) {
+    process.stderr.write(
+      color.stderr.yellow('Aliases are EXPERIMENTAL — Claude may overwrite them on server re-sync.') + '\n'
+    );
+    console.log(`  Stored aliases: ${JSON.stringify(aliasFlags)}`);
+  }
+  console.log(`Next: cc use ${name}`);
+  return 0;
+}
+
+async function cmdUse(rest) {
+  const [name, ...passthrough] = rest;
+  if (!name) throw usageError('Usage: cc use <profile> [...args]');
+  profiles.validateProfileName(name);
+  const dir = profiles.profileDir(name);
+  if (!fs.existsSync(dir)) {
+    const err = new Error(`Profile "${name}" does not exist. Create it with: cc add ${name}`);
+    err.exitCode = 1;
+    throw err;
+  }
+  try {
+    profiles.applyAlias(dir);
+  } catch {
+    // best-effort; never block the launch
+  }
+  return spawnClaude({
+    args: passthrough,
+    profileDir: dir,
+    activeProfile: name,
+  });
+}
+
+function cmdCurrent(rest) {
+  const { flags } = parseFlagsStrict(rest, ['--json']);
+  const value = process.env.CC_ACTIVE_PROFILE || '';
+  if (flags.has('--json')) {
+    const payload = value
+      ? { profile: value, configDir: process.env.CLAUDE_CONFIG_DIR || profiles.profileDir(value) }
+      : { profile: null, configDir: null };
+    process.stdout.write(JSON.stringify(payload) + '\n');
+    return 0;
+  }
+  console.log(value ? value : 'no profile active');
+  return 0;
+}
+
+function cmdList(rest) {
+  const { flags } = parseFlagsStrict(rest, ['--json', '--original']);
+  const list = profiles.listProfiles();
+  const active = process.env.CC_ACTIVE_PROFILE || '';
+  const useOriginal = flags.has('--original');
+
+  const enriched = list.map((p) => {
+    const projectsLink = isLinkLike(path.join(p.dir, 'projects'));
+    const sessionsLink = isLinkLike(path.join(p.dir, 'sessions'));
+    const linked = projectsLink || sessionsLink;
+    const alias = p.alias || {};
+    const displayEmail = useOriginal ? p.email : (alias.email || p.email);
+    return {
+      name: p.name,
+      dir: p.dir,
+      loggedIn: p.loggedIn,
+      email: displayEmail,
+      realEmail: p.email,
+      active: p.name === active,
+      linked,
+      shared: { projects: projectsLink, sessions: sessionsLink },
+      alias,
+    };
+  });
+
+  if (flags.has('--json')) {
+    const payload = enriched.map((p) => ({
+      name: p.name,
+      dir: p.dir,
+      loggedIn: p.loggedIn,
+      email: p.email,
+      active: p.active,
+      linked: p.linked,
+      shared: p.shared,
+      alias: p.alias,
+    }));
+    process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+    return 0;
+  }
+
+  if (enriched.length === 0) {
+    console.log(`No profiles yet in ${profiles.baseDir()}.`);
+    console.log('Create one with:  cc add <name>');
+    return 0;
+  }
+
+  const rows = [['Profile', 'LoggedIn', 'Email', 'Active', 'Linked']];
+  for (const p of enriched) {
+    rows.push([
+      p.name,
+      p.loggedIn ? 'true' : 'false',
+      p.email || '',
+      p.active ? color.stdout.green('*') : '',
+      p.linked ? 'linked' : 'isolated',
+    ]);
+  }
+  console.log(renderTable(rows));
+  return 0;
+}
+
+async function cmdRemove(rest) {
+  const [name] = rest;
+  if (!name) throw usageError('Usage: cc remove <profile>');
+  profiles.validateProfileName(name);
+  const dir = profiles.profileDir(name);
+  if (!fs.existsSync(dir)) {
+    const err = new Error(`Profile "${name}" does not exist at ${dir}.`);
+    err.exitCode = 1;
+    throw err;
+  }
+  console.log('This will permanently delete:');
+  console.log(`  ${dir}`);
+  console.log('including credentials, sessions, projects, plugins, and history.');
+  if (name === process.env.CC_ACTIVE_PROFILE) {
+    console.log(color.stderr.yellow(`Note: "${name}" is the currently active profile in this shell.`));
+  }
+  for (const sub of share.SHARED_SUBDIRS) {
+    const sub_p = path.join(dir, sub);
+    if (isLinkLike(sub_p)) {
+      console.log(`  (${sub}/ is a link to shared storage — only the link will be removed)`);
+    }
+  }
+  const answer = await prompt(`Type the profile name "${name}" to confirm: `);
+  if (answer.trim() !== name) {
+    console.log('Aborted.');
+    return 0;
+  }
+  try {
+    removeRecursivelyPreservingLinks(dir);
+  } catch (err) {
+    throw new Error(`Failed to fully remove ${dir}: ${err.message}`);
+  }
+  console.log(`Removed ${dir}.`);
+  if (name === process.env.CC_ACTIVE_PROFILE) {
+    console.log('Note: the active profile in this shell no longer exists; run `cc use <name>` to switch.');
+  }
+  return 0;
+}
+
+async function cmdLink(rest) {
+  if (rest.length === 0) throw usageError('Usage: cc link <profile> [<profile>...]');
+  const failures = [];
+  for (const name of rest) {
+    if (rest.length > 1) console.log(`\n[${name}]`);
+    try {
+      share.shareLink(name);
+    } catch (err) {
+      process.stderr.write(color.stderr.red(`  error: ${err.message}`) + '\n');
+      failures.push({ name, message: err.message });
+    }
+  }
+  if (rest.length > 1) {
+    const ok = rest.length - failures.length;
+    console.log(`\nSummary: ${ok} succeeded, ${failures.length} failed.`);
+    for (const f of failures) console.log(`  ${f.name}: ${f.message}`);
+  }
+  return failures.length === 0 ? 0 : 1;
+}
+
+async function cmdUnlink(rest) {
+  const [name] = rest;
+  if (!name) throw usageError('Usage: cc unlink <profile>');
+  share.shareUnlink(name);
+  return 0;
+}
+
+async function cmdMigrate(rest) {
+  const [src, dest, ...extra] = rest;
+  if (!src || !dest) throw usageError('Usage: cc migrate <src> <dest>');
+  if (extra.length > 0) throw usageError(`Unexpected extra arguments: ${extra.join(' ')}`);
+  migrateLib.migrate(src, dest);
+  return 0;
+}
+
+async function run(argv) {
+  const [action, ...rest] = argv;
+  if (!action || action === '--help' || action === '-h') {
+    printHelp();
+    return 0;
+  }
+  if (action === 'help') {
+    printHelp(rest[0]);
+    return 0;
+  }
+  switch (action) {
+    case 'add':
+      return await cmdAdd(rest);
+    case 'use':
+      return await cmdUse(rest);
+    case 'list':
+      return cmdList(rest);
+    case 'current':
+      return cmdCurrent(rest);
+    case 'migrate':
+      return await cmdMigrate(rest);
+    case 'link':
+      return await cmdLink(rest);
+    case 'unlink':
+      return await cmdUnlink(rest);
+    case 'remove':
+      return await cmdRemove(rest);
+    default: {
+      process.stderr.write(color.stderr.red(`Unknown command: ${action}`) + '\n\n');
+      printHelp();
+      return 2;
+    }
+  }
+}
+
+module.exports = { run, printHelp, removeRecursivelyPreservingLinks };

package/lib/color.js

@@ -0,0 +1,26 @@
+'use strict';
+
+function colorEnabled(stream) {
+  if (process.env.NO_COLOR && process.env.NO_COLOR.length > 0) return false;
+  if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0') return true;
+  const s = stream || process.stdout;
+  return Boolean(s && s.isTTY);
+}
+
+function wrap(stream, open, close) {
+  return (text) => (colorEnabled(stream) ? `\x1b[${open}m${text}\x1b[${close}m` : String(text));
+}
+
+const stderr = {
+  yellow: wrap(process.stderr, 33, 39),
+  red: wrap(process.stderr, 31, 39),
+  dim: wrap(process.stderr, 2, 22),
+};
+
+const stdout = {
+  green: wrap(process.stdout, 32, 39),
+  bold: wrap(process.stdout, 1, 22),
+  dim: wrap(process.stdout, 2, 22),
+};
+
+module.exports = { colorEnabled, stderr, stdout };

package/lib/format.js

@@ -0,0 +1,26 @@
+'use strict';
+
+function renderTable(rows) {
+  if (!Array.isArray(rows) || rows.length === 0) return '';
+  const cols = rows[0].length;
+  const widths = new Array(cols).fill(0);
+  for (const row of rows) {
+    for (let i = 0; i < cols; i++) {
+      const s = String(row[i] == null ? '' : row[i]);
+      if (s.length > widths[i]) widths[i] = s.length;
+    }
+  }
+  return rows
+    .map((row) =>
+      row
+        .map((v, i) => {
+          const s = String(v == null ? '' : v);
+          return i === cols - 1 ? s : s.padEnd(widths[i] + 2);
+        })
+        .join('')
+        .replace(/\s+$/, ''),
+    )
+    .join('\n');
+}
+
+module.exports = { renderTable };