tokendiet 1.0.0 → 1.2.0

package/README.md

@@ -0,0 +1,47 @@
+# tokendiet
+
+Token optimization gateway CLI for Claude Code. Runs as a local proxy between Claude Code and the Anthropic API, automatically stripping unnecessary tokens before each request.
+
+## Install
+
+```bash
+npm install -g tokendiet
+```
+
+## Usage
+
+```bash
+# Start the gateway (foreground, Ctrl+C to stop)
+tokendiet start --org-token <token>
+
+# With custom cloud API URL
+tokendiet start --org-token <token> --cloud-url https://api.tokendiet.dev
+```
+
+## How it works
+
+1. Starts a local proxy on `localhost:3100`
+2. Patches `~/.claude/settings.json` to route Claude Code traffic through it
+3. Applies stripping strategies to each request before forwarding to Anthropic
+4. Reports token savings to the cloud API
+5. Restores original Claude settings on exit (Ctrl+C)
+
+## Stripping strategies
+
+| Strategy | What it removes |
+|----------|----------------|
+| Whitespace normalization | Unnecessary whitespace from message content and tool results |
+| Schema metadata stripping | JSON Schema metadata (descriptions, titles, examples) from the `tools` array |
+
+Both strategies are deterministic and idempotent.
+
+## Development
+
+```bash
+# npm run start — builds and runs the CLI binary with dev defaults
+npm run start
+```
+
+## License
+
+MIT

package/dist/cli.js

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const start_1 = require("./commands/start");
-const stop_1 = require("./commands/stop");
+const utils_1 = require("./commands/utils");
+async function resolveToken(cliToken) {
+    if (cliToken)
+        return cliToken;
+    const saved = (0, utils_1.loadSavedToken)();
+    if (saved) {
+        console.log(`[tokendiet] Using saved token (${saved.slice(0, 11)}...)`);
+        return saved;
+    }
+    return (0, utils_1.promptForToken)('Enter your API token: ');
+}
 const program = new commander_1.Command();
 program
     .name('tokendiet')
@@ -11,26 +21,37 @@ program
 program
     .command('start')
     .description('Start the local TokenDiet gateway')
-    .option('--api-key <key>', 'Your organization API key')
+    .option('--org-token <token>', 'Your organization API token')
+    .option('--cloud-url <url>', 'Cloud API URL', 'https://tokendiet-production.up.railway.app')
     .option('--port <port>', 'Port to listen on (default: 3100)', '3100')
+    .option('--verbose', 'Show full NestJS logs')
     .action(async (opts) => {
-    const result = await (0, start_1.startGateway)({
-        apiKey: opts.apiKey ?? '',
+    let orgToken = await resolveToken(opts.orgToken);
+    if (!orgToken) {
+        console.error('No token provided. Exiting.');
+        process.exit(1);
+    }
+    let result = await (0, start_1.startGateway)({
+        orgToken,
+        cloudUrl: opts.cloudUrl,
         port: parseInt(opts.port, 10),
+        verbose: opts.verbose ?? false,
     });
-    if (result.success) {
-        console.log(result.message);
+    while (result.unauthorized) {
+        (0, utils_1.clearSavedToken)();
+        console.error('[tokendiet] Token invalid.');
+        orgToken = await (0, utils_1.promptForToken)('Try again (or press Enter to quit): ');
+        if (!orgToken) {
+            console.error('No token provided. Exiting.');
+            process.exit(1);
+        }
+        result = await (0, start_1.startGateway)({
+            orgToken,
+            cloudUrl: opts.cloudUrl,
+            port: parseInt(opts.port, 10),
+            verbose: opts.verbose ?? false,
+        });
     }
-    else {
-        console.error(result.error);
-        process.exit(1);
-    }
-});
-program
-    .command('stop')
-    .description('Stop the local TokenDiet gateway')
-    .action(async () => {
-    const result = await (0, stop_1.stopGateway)();
     if (result.success) {
         console.log(result.message);
     }
@@ -39,12 +60,5 @@ program
         process.exit(1);
     }
 });
-program
-    .command('status')
-    .description('Check whether the TokenDiet gateway is running')
-    .action(() => {
-    console.log('status command not yet implemented');
-    process.exit(0);
-});
 program.parse(process.argv);
 //# sourceMappingURL=cli.js.map

package/dist/commands/analytics-reader.d.ts

@@ -0,0 +1,43 @@
+export interface AnalyticsEvent {
+    timestamp: string;
+    sessionId: string | null;
+    model: string;
+    preStripTokens: number;
+    postStripTotal: number;
+    tokensSaved: number;
+    tokenReductionRate: number;
+    actualCost: number;
+    hypotheticalCost: number;
+    dollarSavings: number;
+    cacheHitRatio: number | null;
+    countMethod?: string;
+}
+export interface CountMethodBreakdown {
+    api: number;
+    local: number;
+    unknown: number;
+}
+export interface AnalyticsSummary {
+    totalRequests: number;
+    totalPreStripTokens: number;
+    totalPostStripTokens: number;
+    totalTokensSaved: number;
+    overallReductionRate: number;
+    totalActualCost: number;
+    totalHypotheticalCost: number;
+    totalDollarSavings: number;
+    averageCacheHitRatio: number | null;
+    perModel: Map<string, ModelSummary>;
+    countMethodBreakdown: CountMethodBreakdown;
+}
+export interface ModelSummary {
+    requests: number;
+    tokensSaved: number;
+    actualCost: number;
+    hypotheticalCost: number;
+    dollarSavings: number;
+}
+export declare function readAnalytics(filePath: string): AnalyticsEvent[];
+export declare function summarize(events: AnalyticsEvent[]): AnalyticsSummary;
+export declare function summarizeSession(events: AnalyticsEvent[], sessionId: string): AnalyticsSummary;
+export declare function formatSummary(summary: AnalyticsSummary): string;

package/dist/commands/analytics-reader.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAnalytics = readAnalytics;
+exports.summarize = summarize;
+exports.summarizeSession = summarizeSession;
+exports.formatSummary = formatSummary;
+const fs = __importStar(require("fs"));
+function readAnalytics(filePath) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const events = [];
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch {
+        }
+    }
+    return events;
+}
+function summarize(events) {
+    const perModel = new Map();
+    const countMethodBreakdown = { api: 0, local: 0, unknown: 0 };
+    let totalPreStripTokens = 0;
+    let totalPostStripTokens = 0;
+    let totalTokensSaved = 0;
+    let totalActualCost = 0;
+    let totalHypotheticalCost = 0;
+    let totalDollarSavings = 0;
+    let cacheHitSum = 0;
+    let cacheHitCount = 0;
+    for (const event of events) {
+        totalPreStripTokens += event.preStripTokens;
+        totalPostStripTokens += event.postStripTotal;
+        totalTokensSaved += event.tokensSaved;
+        totalActualCost += event.actualCost;
+        totalHypotheticalCost += event.hypotheticalCost;
+        totalDollarSavings += event.dollarSavings;
+        if (event.cacheHitRatio != null) {
+            cacheHitSum += event.cacheHitRatio;
+            cacheHitCount++;
+        }
+        if (event.countMethod === 'api') {
+            countMethodBreakdown.api++;
+        }
+        else if (event.countMethod === 'local') {
+            countMethodBreakdown.local++;
+        }
+        else {
+            countMethodBreakdown.unknown++;
+        }
+        const existing = perModel.get(event.model);
+        if (existing) {
+            existing.requests++;
+            existing.tokensSaved += event.tokensSaved;
+            existing.actualCost += event.actualCost;
+            existing.hypotheticalCost += event.hypotheticalCost;
+            existing.dollarSavings += event.dollarSavings;
+        }
+        else {
+            perModel.set(event.model, {
+                requests: 1,
+                tokensSaved: event.tokensSaved,
+                actualCost: event.actualCost,
+                hypotheticalCost: event.hypotheticalCost,
+                dollarSavings: event.dollarSavings,
+            });
+        }
+    }
+    return {
+        totalRequests: events.length,
+        totalPreStripTokens,
+        totalPostStripTokens,
+        totalTokensSaved,
+        overallReductionRate: totalPreStripTokens > 0 ? totalTokensSaved / totalPreStripTokens : 0,
+        totalActualCost,
+        totalHypotheticalCost,
+        totalDollarSavings,
+        averageCacheHitRatio: cacheHitCount > 0 ? cacheHitSum / cacheHitCount : null,
+        perModel,
+        countMethodBreakdown,
+    };
+}
+function summarizeSession(events, sessionId) {
+    return summarize(events.filter((e) => e.sessionId === sessionId));
+}
+function formatSummary(summary) {
+    if (summary.totalRequests === 0) {
+        return 'No analytics data recorded yet.';
+    }
+    const lines = [
+        `Requests: ${summary.totalRequests}`,
+        `Tokens saved: ${summary.totalTokensSaved.toLocaleString()} (${(summary.overallReductionRate * 100).toFixed(1)}% reduction)`,
+        `Actual cost: $${summary.totalActualCost.toFixed(6)}`,
+        `Est. w/o diet: ~$${summary.totalHypotheticalCost.toFixed(6)}`,
+        `Est. savings: ~$${summary.totalDollarSavings.toFixed(6)}`,
+    ];
+    if (summary.averageCacheHitRatio != null) {
+        lines.push(`Avg cache hit: ${(summary.averageCacheHitRatio * 100).toFixed(1)}%`);
+    }
+    const { api, local, unknown } = summary.countMethodBreakdown;
+    const parts = [];
+    if (api > 0)
+        parts.push(`${api} API (exact)`);
+    if (local > 0)
+        parts.push(`${local} local (approx)`);
+    if (unknown > 0)
+        parts.push(`${unknown} unknown`);
+    if (parts.length > 0) {
+        lines.push(`Token counting: ${parts.join(', ')}`);
+    }
+    if (summary.perModel.size > 1) {
+        lines.push('', 'Per model:');
+        for (const [model, data] of summary.perModel) {
+            lines.push(`  ${model}: ${data.requests} req, ${data.tokensSaved.toLocaleString()} tokens saved, ~$${data.dollarSavings.toFixed(6)} est. savings`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=analytics-reader.js.map

package/dist/commands/start.d.ts

@@ -1,9 +1,12 @@
 export interface StartOptions {
-    apiKey: string;
+    orgToken: string;
+    cloudUrl: string;
     port: number;
+    verbose?: boolean;
 }
 export interface StartResult {
     success: boolean;
+    unauthorized?: boolean;
     message?: string;
     error?: string;
 }

package/dist/commands/start.js

@@ -36,9 +36,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startGateway = startGateway;
 const fs = __importStar(require("fs"));
 const childProcess = __importStar(require("child_process"));
+const crypto = __importStar(require("crypto"));
 const net = __importStar(require("net"));
 const path = __importStar(require("path"));
 const utils_1 = require("./utils");
+function detectClientType() {
+    if (process.env.VSCODE_PID || process.env.TERM_PROGRAM === 'vscode') {
+        return 'VS_CODE';
+    }
+    if (process.env.CLAUDE_APP) {
+        return 'MAC_APP';
+    }
+    return 'TERMINAL';
+}
 function isPortAvailable(port) {
     return new Promise((resolve) => {
         const server = net.createServer();
@@ -49,63 +59,118 @@ function isPortAvailable(port) {
         });
     });
 }
-async function startGateway(options) {
-    const { apiKey, port } = options;
-    if (!apiKey) {
-        return {
-            success: false,
-            error: '--api-key is required. Usage: tokendiet start --api-key <key>',
-        };
+async function registerGatewayRun(cloudUrl, orgToken, clientType) {
+    try {
+        const response = await fetch(`${cloudUrl}/v1/gateway-runs`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${orgToken}`,
+            },
+            body: JSON.stringify({ clientType, startedAt: new Date().toISOString() }),
+        });
+        if (response.status === 401) {
+            return 'unauthorized';
+        }
+        if (!response.ok) {
+            console.warn(`[tokendiet] Cloud API returned ${response.status} when registering gateway run`);
+            return null;
+        }
+        const data = (await response.json());
+        return data.gatewayRunId;
     }
-    const existingState = (0, utils_1.readJsonFile)(utils_1.statePath);
-    if (existingState.pid && (0, utils_1.isProcessAlive)(existingState.pid)) {
-        return {
-            success: false,
-            error: `Gateway is already running (PID ${existingState.pid} on port ${existingState.port}).`,
-        };
+    catch (err) {
+        console.warn(`[tokendiet] Could not register gateway run: ${err.message}`);
+        return null;
     }
-    const portFree = await isPortAvailable(port);
+}
+async function startGateway(options) {
+    const { orgToken, cloudUrl, port } = options;
+    let portFree = await isPortAvailable(port);
     if (!portFree) {
+        const killed = (0, utils_1.killOrphanOnPort)(port);
+        if (killed) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            portFree = await isPortAvailable(port);
+        }
+        if (!portFree) {
+            return {
+                success: false,
+                error: `Port ${port} is already in use. Choose a different port with --port.`,
+            };
+        }
+    }
+    const mainScript = path.join(__dirname, '..', 'main.js');
+    const sessionId = crypto.randomUUID();
+    const clientType = detectClientType();
+    let gatewayRunId = null;
+    gatewayRunId = await registerGatewayRun(cloudUrl, orgToken, clientType);
+    if (gatewayRunId === 'unauthorized') {
+        return { success: false, unauthorized: true };
+    }
+    if (!gatewayRunId) {
         return {
             success: false,
-            error: `Port ${port} is already in use. Choose a different port with --port.`,
+            error: `Failed to register gateway run at ${cloudUrl}/v1/gateway-runs. Is the cloud API running?`,
         };
     }
+    (0, utils_1.saveToken)(orgToken);
+    console.log(`[tokendiet] Registered gateway run: ${gatewayRunId}`);
+    const env = {
+        ...process.env,
+        PORT: String(port),
+        TOKENDIET_ORG_TOKEN: orgToken,
+        TOKENDIET_CLOUD_URL: cloudUrl,
+        TOKENDIET_SESSION_ID: sessionId,
+    };
+    if (options.verbose)
+        env.TOKENDIET_VERBOSE = '1';
+    if (gatewayRunId)
+        env.TOKENDIET_GATEWAY_RUN_ID = gatewayRunId;
     const claudeSettings = (0, utils_1.readJsonFile)(utils_1.claudeSettingsPath);
     const previousBaseUrl = claudeSettings.env?.ANTHROPIC_BASE_URL;
-    const mainScript = path.join(__dirname, '..', 'main.js');
-    const child = childProcess.spawn(process.execPath, [mainScript], {
-        detached: true,
-        stdio: 'ignore',
-        env: {
-            ...process.env,
-            PORT: String(port),
-            ANTHROPIC_API_KEY: apiKey,
-        },
-    });
-    child.unref();
-    fs.mkdirSync(utils_1.stateDir, { recursive: true });
-    const state = {
-        pid: child.pid,
-        port,
-        apiKey,
-    };
-    if (previousBaseUrl) {
-        state.previousBaseUrl = previousBaseUrl;
-    }
-    fs.writeFileSync(utils_1.statePath, JSON.stringify(state, null, 2));
     fs.mkdirSync(utils_1.claudeSettingsDir, { recursive: true });
-    const updatedSettings = {
+    const patchedSettings = {
         ...claudeSettings,
         env: {
             ...claudeSettings.env,
             ANTHROPIC_BASE_URL: `http://localhost:${port}`,
         },
     };
-    fs.writeFileSync(utils_1.claudeSettingsPath, JSON.stringify(updatedSettings, null, 2));
-    return {
-        success: true,
-        message: `Gateway started on port ${port} (PID ${child.pid}). Restart Claude Code to route through TokenDiet.`,
+    fs.writeFileSync(utils_1.claudeSettingsPath, JSON.stringify(patchedSettings, null, 2));
+    const restoreClaudeSettings = () => {
+        const currentSettings = (0, utils_1.readJsonFile)(utils_1.claudeSettingsPath);
+        if (currentSettings.env?.ANTHROPIC_BASE_URL !== `http://localhost:${port}`) {
+            return;
+        }
+        const restoredSettings = {
+            ...claudeSettings,
+            env: {
+                ...(claudeSettings.env || {}),
+            },
+        };
+        if (previousBaseUrl) {
+            restoredSettings.env.ANTHROPIC_BASE_URL = previousBaseUrl;
+        }
+        else {
+            delete restoredSettings.env.ANTHROPIC_BASE_URL;
+        }
+        fs.mkdirSync(utils_1.claudeSettingsDir, { recursive: true });
+        fs.writeFileSync(utils_1.claudeSettingsPath, JSON.stringify(restoredSettings, null, 2));
+    };
+    const child = childProcess.spawn(process.execPath, [mainScript], {
+        stdio: 'inherit',
+        env,
+    });
+    const cleanup = () => {
+        restoreClaudeSettings();
+        child.kill('SIGTERM');
+        process.exit(0);
     };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    await new Promise((resolve) => child.on('exit', resolve));
+    restoreClaudeSettings();
+    return { success: true, message: 'Gateway stopped.' };
 }
 //# sourceMappingURL=start.js.map

package/dist/commands/utils.d.ts

@@ -1,6 +1,8 @@
-export declare const stateDir: string;
-export declare const statePath: string;
 export declare const claudeSettingsDir: string;
 export declare const claudeSettingsPath: string;
 export declare function readJsonFile(filePath: string): Record<string, unknown>;
-export declare function isProcessAlive(pid: number): boolean;
+export declare function loadSavedToken(): string | null;
+export declare function saveToken(token: string): void;
+export declare function promptForToken(message?: string): Promise<string | null>;
+export declare function clearSavedToken(): void;
+export declare function killOrphanOnPort(port: number): boolean;

package/dist/commands/utils.js

@@ -33,14 +33,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.claudeSettingsPath = exports.claudeSettingsDir = exports.statePath = exports.stateDir = void 0;
+exports.claudeSettingsPath = exports.claudeSettingsDir = void 0;
 exports.readJsonFile = readJsonFile;
-exports.isProcessAlive = isProcessAlive;
+exports.loadSavedToken = loadSavedToken;
+exports.saveToken = saveToken;
+exports.promptForToken = promptForToken;
+exports.clearSavedToken = clearSavedToken;
+exports.killOrphanOnPort = killOrphanOnPort;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-exports.stateDir = path.join(os.homedir(), '.tokendiet');
-exports.statePath = path.join(exports.stateDir, 'state.json');
+const readline = __importStar(require("readline"));
+const child_process_1 = require("child_process");
 exports.claudeSettingsDir = path.join(os.homedir(), '.claude');
 exports.claudeSettingsPath = path.join(exports.claudeSettingsDir, 'settings.json');
 function readJsonFile(filePath) {
@@ -53,9 +57,62 @@ function readJsonFile(filePath) {
     }
     return {};
 }
-function isProcessAlive(pid) {
+function findPidOnPort(port) {
     try {
-        process.kill(pid, 0);
+        const output = (0, child_process_1.execSync)(`lsof -i :${port} -t`, { encoding: 'utf8' }).trim();
+        const pid = parseInt(output.split('\n')[0], 10);
+        return Number.isFinite(pid) ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+const tokendietDir = path.join(os.homedir(), '.tokendiet');
+const tokenEnvPath = path.join(tokendietDir, '.env');
+function loadSavedToken() {
+    try {
+        if (!fs.existsSync(tokenEnvPath))
+            return null;
+        const content = fs.readFileSync(tokenEnvPath, 'utf-8');
+        const match = content.match(/^TOKENDIET_ORG_TOKEN=(.+)$/m);
+        return match ? match[1].trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveToken(token) {
+    fs.mkdirSync(tokendietDir, { recursive: true });
+    fs.writeFileSync(tokenEnvPath, `TOKENDIET_ORG_TOKEN=${token}\n`, { mode: 0o600 });
+}
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function promptForToken(message = 'Enter your API token: ') {
+    const token = await prompt(message);
+    return token || null;
+}
+function clearSavedToken() {
+    try {
+        if (fs.existsSync(tokenEnvPath))
+            fs.unlinkSync(tokenEnvPath);
+    }
+    catch {
+    }
+}
+function killOrphanOnPort(port) {
+    const pid = findPidOnPort(port);
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 'SIGTERM');
+        console.log(`[tokendiet] Killed orphan process (PID ${pid}) on port ${port}`);
         return true;
     }
     catch {

package/dist/configure-app.d.ts

@@ -0,0 +1,4 @@
+import { NestApplicationOptions } from '@nestjs/common';
+import { NestExpressApplication } from '@nestjs/platform-express';
+export declare function configureApp(app: NestExpressApplication): void;
+export declare const options: NestApplicationOptions;

package/dist/configure-app.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = void 0;
+exports.configureApp = configureApp;
+const BODY_LIMIT = 10_485_760;
+function configureApp(app) {
+    app.useBodyParser('json', { limit: BODY_LIMIT });
+}
+exports.options = {
+    rawBody: true,
+    ...(process.env.TOKENDIET_VERBOSE ? {} : { logger: ['error'] }),
+};
+//# sourceMappingURL=configure-app.js.map

package/dist/main.js

@@ -2,9 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@nestjs/core");
 const app_module_1 = require("./app.module");
+const configure_app_1 = require("./configure-app");
+const cli_output_1 = require("./proxy/cli-output");
 async function bootstrap() {
-    const app = await core_1.NestFactory.create(app_module_1.AppModule, { rawBody: true });
-    await app.listen(process.env.PORT ?? 3100);
+    const app = await core_1.NestFactory.create(app_module_1.AppModule, configure_app_1.options);
+    (0, configure_app_1.configureApp)(app);
+    const port = process.env.PORT ?? 3100;
+    await app.listen(port);
+    if (!process.env.TOKENDIET_VERBOSE) {
+        (0, cli_output_1.printBanner)(Number(port));
+    }
 }
 bootstrap();
 //# sourceMappingURL=main.js.map