@timo972/cc-router 0.7.0

package/dist/cli/cmd-update.js

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import { checkForUpdate, performUpdate, getCurrentVersion, PKG_NAME } from "../utils/self-update.js";
+export function registerUpdate(program) {
+    program
+        .command("update")
+        .description("Check for updates and install the latest version")
+        .option("--check", "Only check, don't install")
+        .action(async (opts) => {
+        console.log(chalk.gray(`Current version: v${getCurrentVersion()}\n`));
+        const check = await checkForUpdate(true);
+        if (!check.updateAvailable) {
+            console.log(chalk.green("✓ Already on the latest version."));
+            return;
+        }
+        console.log(chalk.cyan("New version available: ") +
+            chalk.gray(`v${check.current}`) +
+            chalk.cyan(" → ") +
+            chalk.green.bold(`v${check.latest}`) +
+            chalk.gray(` (${check.diff})`));
+        if (opts.check)
+            return;
+        if (check.diff === "major") {
+            console.log(chalk.yellow("\n⚠ Major version update — may contain breaking changes."));
+            console.log(chalk.yellow(`  Install manually: npm i -g ${PKG_NAME}@${check.latest}`));
+            return;
+        }
+        const ok = await performUpdate(check.latest);
+        if (!ok) {
+            console.log(chalk.red("\nUpdate failed. Try manually:"));
+            console.log(chalk.cyan(`  npm i -g ${PKG_NAME}@${check.latest}`));
+            return;
+        }
+        console.log(chalk.green("\n✓ Update complete."));
+        console.log(chalk.gray("  Restart the proxy to use the new version:"));
+        console.log(chalk.cyan("  cc-router stop && cc-router start"));
+    });
+}

package/dist/cli/index.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerSetup } from "./cmd-setup.js";
+import { registerStart } from "./cmd-start.js";
+import { registerStop, registerRevert } from "./cmd-stop.js";
+import { registerStatus } from "./cmd-status.js";
+import { registerAccounts } from "./cmd-accounts.js";
+import { registerConfigure } from "./cmd-configure.js";
+import { registerDocker } from "./cmd-docker.js";
+import { registerUpdate } from "./cmd-update.js";
+import { registerClient } from "./cmd-client.js";
+import { registerTelemetry } from "./cmd-telemetry.js";
+import { registerLogs } from "./cmd-logs.js";
+import { registerModels } from "./cmd-models.js";
+import { getCurrentVersion, checkForUpdate, printUpdateBanner } from "../utils/self-update.js";
+const program = new Command();
+program
+    .name("cc-router")
+    .description("Round-robin proxy for Claude Max OAuth tokens.\n" +
+    "Distributes Claude Code requests across multiple Claude Max accounts.")
+    .version(getCurrentVersion())
+    .addHelpText("after", `
+Examples:
+  $ cc-router setup              # First-time wizard: extract tokens + configure Claude Code
+  $ cc-router start              # Start proxy (asks preferences on first run, then remembers)
+  $ cc-router start --foreground # Start in foreground (this terminal)
+  $ cc-router start --reconfigure# Re-ask run preferences
+  $ cc-router stop               # Stop proxy (offers to remove auto-start / config)
+  $ cc-router status             # Live dashboard with account stats
+  $ cc-router models list        # List dynamically discovered provider models
+  $ cc-router logs               # View proxy logs (background mode)
+  $ cc-router accounts list      # Show all configured accounts
+  $ cc-router revert             # Restore Claude Code to normal (remove all proxy config)
+  $ cc-router docker up          # Full stack: cc-router + LiteLLM in Docker
+  $ cc-router client connect <url>   # Route Claude Code through a remote CC-Router
+`);
+registerSetup(program);
+registerStart(program);
+registerStop(program);
+registerRevert(program);
+registerStatus(program);
+registerModels(program);
+registerAccounts(program);
+registerConfigure(program);
+registerDocker(program);
+registerUpdate(program);
+registerClient(program);
+registerTelemetry(program);
+registerLogs(program);
+// Background update check — fires on every CLI invocation, uses 6h disk cache
+// so it's essentially free after the first check. Notify on process exit.
+if (!process.env["NO_UPDATE_NOTIFIER"] && !process.env["CI"]) {
+    checkForUpdate().then((check) => {
+        if (check.updateAvailable) {
+            process.on("exit", () => printUpdateBanner(check));
+        }
+    }).catch(() => { });
+}
+program.parse();

package/dist/config/manager.js

@@ -0,0 +1,262 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, chmodSync } from "fs";
+import { randomBytes } from "crypto";
+import { CONFIG_DIR, ACCOUNTS_PATH, CONFIG_PATH } from "./paths.js";
+import { DEFAULT_RATE_LIMITS, ACCOUNT_USER_DEFAULTS, clampPercent } from "../proxy/types.js";
+export const DEFAULT_PROXY_REQUEST_TIMEOUT_MS = 5 * 60 * 1000;
+/** Owner-only permissions for files/dirs that hold OAuth tokens or the proxy secret. */
+const SECRET_FILE_MODE = 0o600;
+const SECRET_DIR_MODE = 0o700;
+export function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: SECRET_DIR_MODE });
+        return;
+    }
+    // Tighten an existing dir that may predate this hardening. No-op on Windows.
+    try {
+        chmodSync(CONFIG_DIR, SECRET_DIR_MODE);
+    }
+    catch { /* best effort */ }
+}
+/**
+ * Atomic + private write for credential files: write tmp as 0600 (umask can
+ * clear bits, so chmod defensively), then rename. rename preserves the source
+ * inode's mode, so the destination ends up 0600 even if it previously existed
+ * world-readable. On Windows `mode` is largely ignored; the file lives under
+ * the user profile and is protected by the profile ACL.
+ */
+function writeFileSecureSync(path, data) {
+    const tmp = path + ".tmp";
+    writeFileSync(tmp, data, { encoding: "utf-8", mode: SECRET_FILE_MODE });
+    try {
+        chmodSync(tmp, SECRET_FILE_MODE);
+    }
+    catch { /* best effort */ }
+    renameSync(tmp, path);
+    try {
+        chmodSync(path, SECRET_FILE_MODE);
+    }
+    catch { /* best effort */ }
+}
+export function accountsFileExists(path) {
+    return existsSync(path ?? ACCOUNTS_PATH);
+}
+export function readAccountsRaw() {
+    return readRawFromPath(ACCOUNTS_PATH);
+}
+function readRawFromPath(path) {
+    if (!existsSync(path))
+        return [];
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+/** Deserialize Account[] from an explicit file path */
+export function readAccountsFromPath(path) {
+    return deserialize(readRawFromPath(path));
+}
+// Escritura atómica: escribe a .tmp y renombra — evita JSON corrupto si el proceso muere mid-write
+export function writeAccountsAtomic(data) {
+    ensureConfigDir();
+    writeAccountsAtomicToPath(ACCOUNTS_PATH, data);
+}
+function writeAccountsAtomicToPath(path, data) {
+    // accounts.json holds plaintext OAuth access + refresh tokens — owner-only.
+    writeFileSecureSync(path, JSON.stringify(data, null, 2));
+}
+export function writeAnthropicAccountsPreservingOtherProviders(data) {
+    ensureConfigDir();
+    const existing = readAccountsRaw();
+    const nonAnthropic = existing.filter(a => a.provider !== undefined && a.provider !== "anthropic_subscription");
+    writeAccountsAtomicToPath(ACCOUNTS_PATH, [...data, ...nonAnthropic]);
+}
+export function upsertAccountRecord(record) {
+    ensureConfigDir();
+    const existing = readAccountsRaw();
+    const next = [
+        ...existing.filter(a => !(a.id === record.id && a.provider === record.provider)),
+        record,
+    ];
+    writeAccountsAtomicToPath(ACCOUNTS_PATH, next);
+}
+export function removeAccountRecordById(id) {
+    ensureConfigDir();
+    const existing = readAccountsRaw();
+    const removed = existing.find(a => a.id === id) ?? null;
+    if (!removed)
+        return null;
+    writeAccountsAtomicToPath(ACCOUNTS_PATH, existing.filter(a => a.id !== id));
+    return removed;
+}
+function normalizeAccountProvider(record) {
+    return record.provider === "openai_subscription"
+        ? "openai_subscription"
+        : "anthropic_subscription";
+}
+export function migrateLegacyAccountProviders(path = ACCOUNTS_PATH) {
+    const records = readRawFromPath(path);
+    let changed = false;
+    const migrated = records.map(record => {
+        if (record.provider !== undefined)
+            return record;
+        changed = true;
+        return { ...record, provider: "anthropic_subscription" };
+    });
+    if (changed)
+        writeAccountsAtomicToPath(path, migrated);
+    return changed;
+}
+export function setProviderAccountsEnabled(provider, enabled, path = ACCOUNTS_PATH) {
+    const records = readRawFromPath(path);
+    let changed = 0;
+    const next = records.map(record => {
+        if (normalizeAccountProvider(record) !== provider)
+            return record;
+        changed++;
+        return { ...record, provider: normalizeAccountProvider(record), enabled };
+    });
+    if (changed > 0)
+        writeAccountsAtomicToPath(path, next);
+    return changed;
+}
+/** Deserialize flat AccountRecord[] from the default path into runtime Account[] */
+export function loadAccounts() {
+    return deserialize(readAccountsRaw());
+}
+/** Load OpenAI ChatGPT/Codex subscription accounts without mixing them into the Anthropic pool. */
+export function loadOpenAIAccounts(path) {
+    const records = readRawFromPath(path ?? ACCOUNTS_PATH);
+    return records
+        .filter(a => a.provider === "openai_subscription")
+        .map(a => ({
+        id: a.id,
+        provider: "openai_subscription",
+        accessToken: a.accessToken,
+        refreshToken: a.refreshToken,
+        expiresAt: a.expiresAt,
+        enabled: a.enabled !== false,
+    }));
+}
+export function saveOpenAIAccounts(accounts) {
+    ensureConfigDir();
+    const existing = readAccountsRaw();
+    const nonOpenAI = existing.filter(a => a.provider !== "openai_subscription");
+    const records = accounts.map(a => ({
+        id: a.id,
+        provider: "openai_subscription",
+        accessToken: a.accessToken,
+        refreshToken: a.refreshToken,
+        expiresAt: a.expiresAt,
+        scopes: ["openid", "profile", "email", "offline_access"],
+        enabled: a.enabled,
+    }));
+    writeAccountsAtomicToPath(ACCOUNTS_PATH, [...nonOpenAI, ...records]);
+}
+function parseProxyConfig(raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new TypeError(`${CONFIG_PATH} must contain a JSON object`);
+    }
+    return parsed;
+}
+/**
+ * Read config for a read-modify-write operation.
+ *
+ * Unlike readConfig(), this deliberately propagates read and parse failures so
+ * callers cannot replace an unreadable or malformed user config with defaults.
+ */
+export function readConfigStrict() {
+    try {
+        return parseProxyConfig(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return {};
+        throw err;
+    }
+}
+export function readConfig() {
+    if (!existsSync(CONFIG_PATH))
+        return {};
+    try {
+        return readConfigStrict();
+    }
+    catch (err) {
+        console.warn(`Warning: ${CONFIG_PATH} contains invalid JSON: ${err.message}`);
+        try {
+            const backupPath = CONFIG_PATH + ".bak";
+            copyFileSync(CONFIG_PATH, backupPath);
+            console.warn(`  Backup saved to ${backupPath}`);
+        }
+        catch { /* best-effort backup */ }
+        console.warn(`  Using default configuration for this session.`);
+        return {};
+    }
+}
+export function getProxyRequestTimeoutMs() {
+    const { proxyRequestTimeoutMs, proxyRequesTime } = readConfig();
+    const timeoutMs = proxyRequestTimeoutMs ?? proxyRequesTime;
+    return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? timeoutMs
+        : DEFAULT_PROXY_REQUEST_TIMEOUT_MS;
+}
+function normalizeProxyConfig(cfg) {
+    const { proxyRequesTime, ...normalized } = cfg;
+    const timeoutMs = normalized.proxyRequestTimeoutMs ?? proxyRequesTime;
+    normalized.proxyRequestTimeoutMs =
+        typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
+            ? timeoutMs
+            : DEFAULT_PROXY_REQUEST_TIMEOUT_MS;
+    return normalized;
+}
+export function writeConfig(cfg) {
+    ensureConfigDir();
+    // config.json holds proxySecret and client.remoteSecret — owner-only.
+    writeFileSecureSync(CONFIG_PATH, JSON.stringify(normalizeProxyConfig(cfg), null, 2));
+}
+export function generateProxySecret() {
+    return "cc-rtr-" + randomBytes(16).toString("hex");
+}
+// ─── Accounts ─────────────────────────────────────────────────────────────────
+function deserialize(records) {
+    return records.filter(a => a.provider === undefined || a.provider === "anthropic_subscription").map(a => ({
+        id: a.id,
+        tokens: {
+            accessToken: a.accessToken,
+            refreshToken: a.refreshToken,
+            expiresAt: a.expiresAt,
+            scopes: a.scopes ?? ["user:inference", "user:profile"],
+        },
+        healthy: true,
+        busy: false,
+        requestCount: 0,
+        errorCount: 0,
+        lastUsed: 0,
+        lastRefresh: 0,
+        consecutiveErrors: 0,
+        rateLimits: { ...DEFAULT_RATE_LIMITS },
+        enabled: a.enabled !== false, // default true
+        sessionLimitPercent: a.sessionLimitPercent !== undefined
+            ? clampPercent(a.sessionLimitPercent)
+            : ACCOUNT_USER_DEFAULTS.sessionLimitPercent,
+        weeklyLimitPercent: a.weeklyLimitPercent !== undefined
+            ? clampPercent(a.weeklyLimitPercent)
+            : ACCOUNT_USER_DEFAULTS.weeklyLimitPercent,
+    }));
+}
+/** Serialize runtime Account[] back to the flat on-disk AccountRecord[] shape. */
+export function serialize(accounts) {
+    return accounts.map(a => ({
+        id: a.id,
+        provider: "anthropic_subscription",
+        accessToken: a.tokens.accessToken,
+        refreshToken: a.tokens.refreshToken,
+        expiresAt: a.tokens.expiresAt,
+        scopes: a.tokens.scopes,
+        enabled: a.enabled,
+        sessionLimitPercent: a.sessionLimitPercent,
+        weeklyLimitPercent: a.weeklyLimitPercent,
+    }));
+}

package/dist/config/paths.js

@@ -0,0 +1,21 @@
+import os from "os";
+import path from "path";
+// All paths support env var overrides so Docker can inject them via environment
+export const CONFIG_DIR = path.join(os.homedir(), ".cc-router");
+export const ACCOUNTS_PATH = process.env["ACCOUNTS_PATH"] ??
+    path.join(CONFIG_DIR, "accounts.json");
+export const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+export const PROXY_PORT = parseInt(process.env["PORT"] ?? "3456", 10);
+export const LITELLM_PORT = 4000;
+// When set, the server forwards to LiteLLM instead of Anthropic directly
+export const LITELLM_URL = process.env["LITELLM_URL"];
+// Proxy-level config (password, future settings) — separate from accounts.json
+export const CONFIG_PATH = process.env["CONFIG_PATH"] ??
+    path.join(CONFIG_DIR, "config.json");
+// Anonymous telemetry state — install id + opt-in flag
+export const TELEMETRY_PATH = process.env["TELEMETRY_PATH"] ??
+    path.join(CONFIG_DIR, "telemetry.json");
+// Daemon PID file — written by daemon process, read by stop/status
+export const PID_PATH = path.join(CONFIG_DIR, "cc-router.pid");
+// Log file — daemon stdout/stderr redirect here
+export const LOG_PATH = path.join(CONFIG_DIR, "cc-router.log");

package/dist/config/telemetry.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, writeFileSync, renameSync } from "fs";
+import { randomUUID } from "crypto";
+import { TELEMETRY_PATH } from "./paths.js";
+import { ensureConfigDir } from "./manager.js";
+function defaultState() {
+    return {
+        // Opt-in: telemetry stays off until the user explicitly enables it with
+        // `cc-router telemetry on`. Nothing is sent on first run.
+        enabled: false,
+        installId: randomUUID(),
+        firstRunAt: new Date().toISOString(),
+    };
+}
+// Read the telemetry state, creating and persisting a fresh one on first run.
+// Malformed files are treated as missing so a corrupted file can't crash the CLI.
+export function loadTelemetryState() {
+    if (!existsSync(TELEMETRY_PATH)) {
+        const state = defaultState();
+        writeTelemetryState(state);
+        return state;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(TELEMETRY_PATH, "utf-8"));
+        // Fill any missing fields to keep the file forward-compatible. Missing
+        // `enabled` defaults to OFF (opt-in).
+        const state = {
+            enabled: raw.enabled ?? false,
+            installId: raw.installId ?? randomUUID(),
+            firstRunAt: raw.firstRunAt ?? new Date().toISOString(),
+        };
+        if (!raw.installId) {
+            writeTelemetryState(state);
+        }
+        return state;
+    }
+    catch {
+        const state = defaultState();
+        writeTelemetryState(state);
+        return state;
+    }
+}
+// Atomic write: .tmp + rename, same pattern as writeAccountsAtomic
+export function writeTelemetryState(state) {
+    ensureConfigDir();
+    const tmp = TELEMETRY_PATH + ".tmp";
+    writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+    renameSync(tmp, TELEMETRY_PATH);
+}
+// Returns true only if the user has not opted out through any mechanism:
+//   - DO_NOT_TRACK=1     (de-facto standard)
+//   - CC_ROUTER_TELEMETRY=0  (project-specific override)
+//   - `cc-router telemetry off` (persisted enabled: false)
+export function isTelemetryEnabled() {
+    if (process.env["DO_NOT_TRACK"] === "1")
+        return false;
+    if (process.env["CC_ROUTER_TELEMETRY"] === "0")
+        return false;
+    try {
+        return loadTelemetryState().enabled;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/daemon/launcher.js

@@ -0,0 +1,163 @@
+import { spawn } from "child_process";
+import { openSync, closeSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import chalk from "chalk";
+import { LOG_PATH, PROXY_PORT } from "../config/paths.js";
+import { ensureConfigDir } from "../config/manager.js";
+import { writePid, getRunningPid, isProcessAlive, removePid, isProxyRunning } from "./pid.js";
+import { isWindows } from "../utils/platform.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLI_ENTRY = join(__dirname, "..", "cli", "index.js");
+/** Launch cc-router as a detached background process. */
+export async function launchDaemon(opts = {}) {
+    const port = opts.port ?? PROXY_PORT;
+    // Already running?
+    if (await isProxyRunning(port)) {
+        console.log(chalk.green(`✓ CC-Router is already running on port ${port}`));
+        console.log(chalk.gray(`  Logs: cc-router logs  |  Stop: cc-router stop`));
+        return true;
+    }
+    ensureConfigDir();
+    // Build args
+    const args = [CLI_ENTRY, "start", "--foreground", "--port", String(port)];
+    if (opts.litellmUrl)
+        args.push("--litellm", opts.litellmUrl);
+    if (opts.accountsPath)
+        args.push("--accounts", opts.accountsPath);
+    // Build env
+    const env = { ...process.env, CC_ROUTER_DAEMON: "1" };
+    if (opts.serverMode)
+        env["HOST"] = "0.0.0.0";
+    // Open log file (append mode) for stdout+stderr redirection
+    let logFd;
+    try {
+        logFd = openSync(LOG_PATH, "a");
+    }
+    catch (err) {
+        console.error(chalk.red(`✗ Cannot open log file: ${LOG_PATH}`));
+        console.error(chalk.gray(`  ${err.message}`));
+        return false;
+    }
+    const child = spawn(process.execPath, args, {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env,
+        windowsHide: true,
+    });
+    if (!child.pid) {
+        console.error(chalk.red("✗ Failed to start background process"));
+        return false;
+    }
+    writePid(child.pid);
+    child.unref();
+    closeSync(logFd);
+    // Wait for health endpoint to respond
+    console.log(chalk.gray("  Starting CC-Router in background..."));
+    const healthy = await waitForHealth(port, 5_000);
+    if (healthy) {
+        console.log(chalk.green(`✓ CC-Router running in background on port ${port}`));
+        return true;
+    }
+    else {
+        console.log(chalk.yellow(`⚠ Process started (PID ${child.pid}) but not yet responding.`));
+        console.log(chalk.gray(`  Check logs: cc-router logs`));
+        return false;
+    }
+}
+/** Stop the cc-router daemon process. */
+export async function stopDaemon(port = PROXY_PORT) {
+    // Try PID-based stop first
+    const pid = getRunningPid();
+    if (pid !== null) {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Already dead
+            removePid();
+            return true;
+        }
+        // Wait for graceful shutdown (up to 5s)
+        const died = await waitForDeath(pid, 5_000);
+        if (!died) {
+            // Force kill
+            try {
+                process.kill(pid, "SIGKILL");
+            }
+            catch { /* already dead */ }
+            // Verify it actually died
+            await new Promise(r => setTimeout(r, 500));
+            if (isProcessAlive(pid)) {
+                console.log(chalk.yellow(`  ⚠ Could not kill process ${pid}`));
+                return false; // don't remove PID file — process is still alive
+            }
+        }
+        removePid();
+        return true;
+    }
+    // Fallback: kill by port (handles foreground processes or legacy PM2)
+    return killByPort(port);
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+async function waitForHealth(port, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const res = await fetch(`http://localhost:${port}/cc-router/health`, {
+                signal: AbortSignal.timeout(500),
+            });
+            if (res.ok)
+                return true;
+        }
+        catch { /* not ready yet */ }
+        await sleep(300);
+    }
+    return false;
+}
+async function waitForDeath(pid, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (!isProcessAlive(pid))
+            return true;
+        await sleep(200);
+    }
+    return false;
+}
+async function killByPort(port) {
+    const { execFile } = await import("child_process");
+    const { promisify } = await import("util");
+    const execFileAsync = promisify(execFile);
+    try {
+        if (isWindows()) {
+            const { stdout } = await execFileAsync("netstat", ["-ano"]);
+            const match = stdout
+                .split("\n")
+                .find(line => line.includes(`:${port}`) && line.includes("LISTENING"));
+            if (!match)
+                return false;
+            const pid = match.trim().split(/\s+/).at(-1);
+            if (!pid || isNaN(Number(pid)))
+                return false;
+            await execFileAsync("taskkill", ["/PID", pid, "/F"]);
+            return true;
+        }
+        else {
+            const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`]);
+            const pids = stdout.trim().split("\n").filter(Boolean);
+            if (pids.length === 0)
+                return false;
+            for (const p of pids) {
+                await execFileAsync("kill", ["-TERM", p]);
+            }
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}